Given two arrays of integers nums1 and nums2, return the number of triplets formed (type 1 and type 2) under the following rules:

Type 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
Type 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.

 
Example 1:
Input: nums1 = [7,4], nums2 = [5,2,8,9]
Output: 1
Explanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8). 

Example 2:
Input: nums1 = [1,1], nums2 = [1,1,1]
Output: 9
Explanation: All Triplets are valid, because 1^2 = 1 * 1.
Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]^2 = nums2[j] * nums2[k].
Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]^2 = nums1[j] * nums1[k].

Example 3:
Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
Output: 2
Explanation: There are 2 valid triplets.
Type 1: (3,0,2).  nums1[3]^2 = nums2[0] * nums2[2].
Type 2: (3,0,1).  nums2[3]^2 = nums1[0] * nums1[1].

Example 4:
Input: nums1 = [4,7,9,11,23], nums2 = [3,5,1024,12,18]
Output: 0
Explanation: There are no valid triplets.

 
Constraints:

1 <= nums1.length, nums2.length <= 1000
1 <= nums1[i], nums2[i] <= 10^5

Difficulty: interview

Starter code:

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        

Solutions:
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def triplets(nums1, nums2):
            sq = collections.Counter(x * x for x in nums1)
            num = collections.Counter(nums2)
            
            res = 0
            keys = sorted(num.keys())
            for j, x in enumerate(keys):
                if num[x] > 1 and x * x in sq:
                    res += num[x] * (num[x] - 1) // 2 * sq[x * x]
                for y in keys[j+1:]:
                    if x * y in sq:
                        res += num[x] * num[y] * sq[x * y]
            return res
        
        return triplets(nums1, nums2) + triplets(nums2, nums1)                

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        count1 = Counter(nums1)
        count2 = Counter(nums2)
        nums1 = sorted(count1.keys())
        nums2 = sorted(count2.keys())
        tot = 0
        for (c1, n1, c2, n2) in [(count1, nums1, count2, nums2), (count2, nums2, count1, nums1)]:
            for a in n1:
                s = a ** 2
                for b in n2:
                    if b > a:
                        break
                    if s % b == 0 and s // b in c2:
                        print((a, b))
                        if b == a:
                            if c2[b] >= 2:
                                tot += c1[a] * comb(c2[b], 2)
                        else:
                            tot += c1[a] * c2[b] * c2[s // b]
        return tot
                    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        
        def calc(a : List[int], b : List[int]):
            from collections import defaultdict
            freq = defaultdict(int)
            for ai in a:
                freq[ai] += 1
            _ans = 0
            for bi in b:
                t = bi * bi
                for k in freq:
                    if t % k != 0 or t/k not in freq : continue
                    elif t/k == k : _ans += freq[k] * (freq[k] - 1)
                    else : _ans += freq[k] * freq[t/k]
            return int(_ans/2)
        return calc(nums1, nums2) + calc(nums2, nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        prod2 = collections.defaultdict(int)
                                       
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                prod = nums2[i]*nums2[j]
                
                if prod in prod2:
                    prod2[prod]+=1
                else:
                    prod2[prod]=1
            
        res = 0

        for e in nums1:
            
            if e**2 in prod2:
                res += prod2[e**2]
                
        prod1 = collections.defaultdict(int)
                                       
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                prod = nums1[i]*nums1[j]
                
                if prod in prod1:
                    prod1[prod]+=1
                else:
                    prod1[prod]=1
                    
        for e in nums2:
            if e*e in prod1:
                res += prod1[e*e]
                
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ret = 0
        dict1 = defaultdict(int)
        dict2 = defaultdict(int)
        
        for j in range(len(nums2)):
            for k in range(j+1, len(nums2)):
                dict2[nums2[j] * nums2[k]] += 1
        
        for j in range(len(nums1)):
            for k in range(j+1, len(nums1)):
                dict1[nums1[j] * nums1[k]] += 1
                        
        for i in range(len(nums1)):
            if nums1[i]**2 in dict2:
                ret += dict2[nums1[i]**2]
                        
        for i in range(len(nums2)):
            if nums2[i]**2 in dict1:
                ret += dict1[nums2[i]**2]
        return ret
            
            


from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1, n2 = Counter([x*x for x in nums1]), Counter([x*x for x in nums2])
        count = 0
        l1, l2 = len(nums1), len(nums2)
        for i in range(l2-1):
            for j in range(i+1, l2):
                count += n1[nums2[i] * nums2[j]]
        for i in range(l1-1):
            for j in range(i+1, l1):
                count += n2[nums1[i] * nums1[j]]
        
        return count


from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find_triplets(nums_1, nums_2):
            ans = 0
            target = list(map(lambda x: x**2, nums_1))
            count = Counter(target)
            for j in range(len(nums_2)):
                for k in range(j+1, len(nums_2)):
                    if nums_2[j] * nums_2[k] in count:
                        ans += count[nums_2[j] * nums_2[k]]
            return ans

        return find_triplets(nums1, nums2) + find_triplets(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1=collections.defaultdict(int)
        d2=collections.defaultdict(int)
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                d1[nums1[i]*nums1[j]]+=1
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                d2[nums2[i]*nums2[j]]+=1
        c=0
        for i in nums1:
            c+=d2[i*i]
        for i in nums2:
            c+=d1[i*i]
        print(d1,d2)
        return c

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def helper(a, b):
            count = Counter(x ** 2 for x in a)
            return sum(count[x * y] for x, y in itertools.combinations(b, 2))

        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        l1 = len(nums1)
        l2 = len(nums2)
        upper1 = []
        upper2 = []
        for i in range(l1):
            for j in range(i+1, l1):
                upper1.append(nums1[i]*nums1[j])
        for i in range(l2):
            for j in range(i+1, l2):
                upper2.append(nums2[i]*nums2[j])
        Count_upper1 = collections.Counter(upper1)
        Count_upper2 = collections.Counter(upper2)
        count = 0
        for i in range(l1):
            count += Count_upper2[nums1[i]**2]
        for i in range(l2):
            count += Count_upper1[nums2[i]**2]
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        target1 = {}
        target2 = {}
        
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                v = nums1[i] * nums1[j]
                if v in target1:
                    target1[v] += 1
                else :
                    target1[v] = 1
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                v = nums2[i] * nums2[j]
                if v in target2:
                    target2[v] += 1
                else:
                    target2[v] = 1
        
        answer = 0
        print(target1, target2)
        for num in nums1:
            if num*num in target2:
                answer += target2[num*num]
        for num in nums2:
            if num*num in target1:
                answer += target1[num*num]
                
        return answer

class Solution:
    def numTriplets(self, a1: List[int], a2: List[int]) -> int:        
        ans, m1, m2, n1, n2 = 0, Counter([x**2 for x in a1]), Counter([x**2 for x in a2]), len(a1), len(a2)
        for i in range(n1-1):
            for j in range(i+1, n1):
                ans += m2[a1[i]*a1[j]]
        for i in range(n2-1):
            for j in range(i+1, n2):
                ans += m1[a2[i]*a2[j]]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        totalcount=0
        nums1sq = defaultdict(int)
        for sq_val in [x*x for x in nums1]:
            nums1sq[sq_val]+=1
        nums2sq = defaultdict(int)
        for sq_val in [x*x for x in nums2]:
            nums2sq[sq_val]+=1
        #count type1
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                totalcount+=nums1sq[nums2[i]*nums2[j]]
        #count type2
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                totalcount+=nums2sq[nums1[i]*nums1[j]]
        return totalcount
                    
        


from typing import List
from collections import Counter
class Solution:
  def numTriplets(self, en1: List[int], en2: List[int]) -> int:




    counter1=Counter(en1)
    counter2=Counter(en2)

  
    ct = 0
    for ele1,ct1 in list(counter1.items()):
      tot = ele1*ele1
      for ele2 in counter2:
        div,mod = divmod(tot,ele2)
        if mod !=0: continue
        if div in counter2:
          if ele2 == div:
            ct+=ct1*counter2[ele2]*(counter2[div]-1)
          else:
            ct+=ct1*counter2[ele2]*counter2[div]
            
    for ele1,ct1 in list(counter2.items()):
      tot = ele1*ele1
      for ele2 in counter1:
        div,mod = divmod(tot,ele2)
        if mod !=0: continue
        if div in counter1:
          if ele2 == div:
            ct+=ct1*counter1[ele2]*(counter1[div]-1)
          else:
            ct+=ct1*counter1[ele2]*counter1[div]

    return ct//2


class Solution:
    def numTriplets(self, a1: List[int], a2: List[int]) -> int:        
        ans, m1, m2, n1, n2 = 0, Counter([x**2 for x in a1]), Counter([x**2 for x in a2]), len(a1), len(a2)
        for i in range(n1-1):
            for j in range(i+1, n1):
                ans += m2[a1[i]*a1[j]]
        for i in range(n2-1):
            for j in range(i+1, n2):
                ans += m1[a2[i]*a2[j]]
        return ans

        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        n1 = collections.Counter([num**2 for num in nums1])
        cnt = 0
        for i in range(1, len(nums2)):
            for j in range(i):
                if nums2[i]*nums2[j] in n1:
                    cnt += n1[nums2[i]*nums2[j]]
        
        n1 = collections.Counter([num**2 for num in nums2])
        for i in range(1, len(nums1)):
            for j in range(i):
                if nums1[i]*nums1[j] in n1:
                    cnt += n1[nums1[i]*nums1[j]]
        return cnt

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        counter1 = Counter(num * num for num in nums1)
        counter2 = Counter(num * num for num in nums2)
        
        res = 0
        
        n, m = len(nums1), len(nums2)
        for i in range(n - 1):
            for j in range(i + 1, n):
                curr = nums1[i] * nums1[j]
                res += counter2[curr]
        
        for i in range(m - 1):
            for j in range(i + 1, m):
                curr = nums2[i] * nums2[j]
                res += counter1[curr]
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans, m1, m2 = 0, Counter([x**2 for x in nums1]), Counter([x**2 for x in nums2])
        n1, n2 = len(nums1), len(nums2)
        
        for i in range(n1-1):
            for j in range(i+1, n1):
                ans += m2[nums1[i]*nums1[j]]
        for i in range(n2-1):
            for j in range(i+1, n2):
                ans += m1[nums2[i]*nums2[j]]
        return ans

#from collections import defaultdict
from collections import  Counter

class Solution:
    
    def check_square(self, c, nums):
        tot = 0
        for j in range(len(nums)):
            for k in range(j+1, len(nums)):
                tot += c[nums[j] * nums[k]]
        return tot
                
    def count_squares(self, nums):
        c = Counter([elem**2 for elem in nums])
        return c
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1 = self.count_squares(nums1)
        c2 = self.count_squares(nums2)
        
        
        sol1 = self.check_square(c1, nums2)
        sol2 = self.check_square(c2, nums1)
        
        return sol1+sol2

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1_cnts, n2_cnts = Counter(nums1), Counter(nums2)
        
        good = 0
        for n1, cnt in list(n1_cnts.items()):
            n2_cnts_copy = n2_cnts.copy()
            for n2j in nums2:
                n2_cnts_copy[n2j] -= 1
                good += cnt*n2_cnts_copy[pow(n1, 2)/n2j]
                
        for n2, cnt in list(n2_cnts.items()):
            n1_cnts_copy = n1_cnts.copy()
            for n1j in nums1:
                n1_cnts_copy[n1j] -= 1
                good += cnt*n1_cnts_copy[pow(n2, 2)/n1j]
                
        return good
            
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1 = collections.Counter([i*i for i in nums1])
        c2 = collections.Counter([i*i for i in nums2])
        res = 0
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                res += c2[nums1[i]*nums1[j]]
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                res += c1[nums2[i]*nums2[j]]
        return res

class Solution:
    def wrapper(self, toSquare, toProd):
        
        #create a hash table of count of unique squared ints in arr 1
        table = {}
        for integer in toSquare:
            squared = integer**2
            if squared not in table:
                table[squared] = 1
            else:
                table[squared] += 1
        
        counter = 0
        #get all pairs products, check in hash table, if so, inc counter by count in table
        i = 0
        while i < len(toProd): #minus one ok too?
            j = i + 1
            while j < len(toProd):
                product = toProd[i] * toProd[j]
                if product in table:
                    counter += table[product]
                j += 1
            i += 1
        
        return counter
            
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        counter = 0
        counter += self.wrapper(nums1, nums2)
        counter += self.wrapper(nums2, nums1)
        return counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        set1 = collections.Counter([x*x for x in nums1])
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                ans += set1[nums2[i]*nums2[j]]
        set2 = collections.Counter([x*x for x in nums2])
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                ans += set2[nums1[i]*nums1[j]]
                
        return ans
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        import numpy as np
        l1 = len(nums1)
        l2 = len(nums2)
        upper1 = list(np.outer(np.array(nums1), np.array(nums1))[np.triu_indices(l1, 1)])
        upper2 = list(np.outer(np.array(nums2), np.array(nums2))[np.triu_indices(l2, 1)])
        Count_upper1 = collections.Counter(upper1)
        Count_upper2 = collections.Counter(upper2)
        count = 0
        for i in range(max(l1,l2)):
            if i < l1:
                count += Count_upper2[nums1[i]**2]
            if i < l2:
                count += Count_upper1[nums2[i]**2]
        return count

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        new1 = Counter(nums1)
        new2 = Counter(nums2)
        
        def helper(a, b):
            count = 0

            for key in a:
                target = key ** 2

                for kk in b:
                    c = target // kk

                    if c < kk:
                        continue
                    elif c == kk:
                        count += b[kk] * (b[kk] - 1) * a[key] // 2
                    else:
                        if target % kk == 0 and c in b:
                            count += b[kk] * b[c] * a[key]
            
            return count

        return helper(new1, new2) + helper(new2, new1)

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        squares1 = Counter([x**2 for x in nums1])
        squares2 = Counter([x**2 for x in nums2])
        
        count = 0
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                if nums1[i]*nums1[j] in squares2:
                    count = count + squares2[nums1[i]*nums1[j]]
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                if nums2[i]*nums2[j] in squares1:
                    count = count + squares1[nums2[i]*nums2[j]]
                    
        return count
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sq_cnt1 = Counter([x*x for x in nums1])
        sq_cnt2 = Counter([x*x for x in nums2])
        count = 0
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                if nums1[i]*nums1[j] in sq_cnt2:
                    count += sq_cnt2[nums1[i]*nums1[j]]
                    
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                if nums2[i]*nums2[j] in sq_cnt1:
                    count += sq_cnt1[nums2[i]*nums2[j]]
                    
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def cal(lst1, lst2):
            count = 0
            d = {}
            for i in range(len(lst1)):
                v = lst1[i]*lst1[i] 
                d[v] = d.get(v, 0)+1
            for j in range(len(lst2)):
                for k in range(j+1, len(lst2)):
                    v = lst2[j]*lst2[k] 
                    if v in d:
                        count += d[v]
            return count

        return cal(nums1, nums2) + cal(nums2, nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        N1 = len(nums1)
        N2 = len(nums2)
        d1 = collections.defaultdict(int)
        for j in range(N1):
            for k in range(j + 1, N1):
                d1[nums1[j] * nums1[k]] += 1
        d2 = collections.defaultdict(int)
        for j in range(N2):
            for k in range(j + 1, N2):
                d2[nums2[j] * nums2[k]] += 1
        ans = 0
        for i in range(N1):
            ans += d2[nums1[i] * nums1[i]]
        for i in range(N2):
            ans += d1[nums2[i] * nums2[i]]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        

        c1 = collections.Counter([x**2 for x in nums1])
        c2 = collections.Counter([y**2 for y in nums2])
        ans = 0
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                p = nums2[i]*nums2[j]
                ans += c1[p]
        
        
        for ii in range(len(nums1)):
            for jj in range(ii+1, len(nums1)):
                p = nums1[ii]*nums1[jj]
                ans += c2[p]
        
        return ans
        


from collections import defaultdict

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        mp1 = defaultdict(int)
        mp2 = defaultdict(int)
        for n in nums1:
            mp1[n*n] += 1
        for n in nums2:
            mp2[n*n] += 1

        products1 = self.products(nums1)
        products2 = self.products(nums2)
        # print(products1, products2, mp1, mp2)
        
        score = 0
        for p in products1:
            if mp2.get(p):
                score += mp2[p]
        for p in products2:
            if mp1.get(p):
                score += mp1[p]
        
        return score

    
    def products(self, nums):
        products = []
        n = len(nums)
        for i in range(0, n-1):
            for m in nums[i+1:]:
                products.append(nums[i]*m)
        return products
        
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        m = len(nums1)
        n = len(nums2)
        
        pairs1 = []
        pairs2 = []
        
        for i in range(n):
            for j in range(i+1,n):
                pairs2.append(nums2[i]*nums2[j])
                
        for i in range(m):
            for j in range(i+1,m):
                pairs1.append(nums1[i]*nums1[j])
        pairs1.sort()
        pairs2.sort()
        if len(pairs1) == 0 or len(pairs2) == 0:
            return 0
        # print(pairs1,pairs2)
        def bs1(arr,key):
            if arr[0] > key:
                return -1
            if arr[-1] < key:
                return -1
            lo = 0
            hi = len(arr)-1
            left = -1
            while lo <= hi:
                mid = (lo+hi)//2
                if arr[mid] < key:
                    lo = mid+1
                elif arr[mid] == key:
                    left = mid
                    hi=mid-1
                else:
                    hi = mid-1
            # print('left ',left, key,arr)       
            return left
        
        def bs2(arr,key):
            if arr[0] > key:
                return -1
            if arr[-1] < key:
                return -1
            lo = 0
            hi = len(arr)-1
            right = -1
            while lo <= hi:
                mid = (lo+hi)//2
                if arr[mid] < key:
                    lo = mid+1
                elif arr[mid] == key:
                    right = mid
                    lo=mid+1
                else:
                    hi = mid-1
                    
            return right
        
        ans = 0
        for i in nums1:
            sq = i*i
            left = bs1(pairs2,sq)
            right = bs2(pairs2,sq)
            if left == -1:
                continue
            ans += right-left+1
            
        for i in nums2:
            sq = i*i
            left = bs1(pairs1,sq)
            right = bs2(pairs1,sq)
            if left == -1:
                continue
            ans += right-left+1
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count=0
        dict1={}
        dict2={}
        for i in nums1:
            x=i*i
            if x not in dict1.keys():
                dict1[x]=1
            else:
                dict1[x]=dict1[x]+1
        for j in nums2:
            x=j*j
            if x not in dict2.keys():
                dict2[x]=1
            else:
                dict2[x]=dict2[x]+1
        print(dict1)
        print(dict2)
        for j in range(0,len(nums2)):
            for k in range(j+1,len(nums2)):
                if nums2[k]*nums2[j] in dict1.keys():
                    count=count+dict1[nums2[j]*nums2[k]]
        for j in range(0,len(nums1)):
            for k in range(j+1,len(nums1)):
                if nums1[j]*nums1[k] in dict2.keys():
                    count=count+dict2[nums1[j]*nums1[k]]
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def getRoots(nums):
            prods = []
            for (i, j) in itertools.combinations(nums, 2):
                    prods.append(i*j)
            return prods
        
        def ways(nums1, nums2):
            ans = 0
            square = collections.Counter([n**2 for n in nums1])
            prods = getRoots(nums2)
            # print(roots)
            for p in prods:
                    ans += square[p]
            return ans
        
        return ways(nums1, nums2) + ways(nums2, nums1)
        


from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        new1 = Counter(nums1)
        new2 = Counter(nums2)
        
        def helper(a, b):
            count = 0

            for key in a:
                target = key ** 2

                for kk in sorted(b.keys()):
                    c = target // kk

                    if c < kk:
                        break
                    elif c == kk:
                        count += b[kk] * (b[kk] - 1) * a[key] // 2
                    else:
                        if target % kk == 0 and c in b:
                            count += b[kk] * b[c] * a[key]
            
            return count

        return helper(new1, new2) + helper(new2, new1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def typeone(n1,n2):
            L1=len(n1)
            L2=len(n2)
            dic={}
            count=0
            for j in range(L2-1):
                for k in range(j+1,L2):
                    if n2[j]*n2[k] not in dic:
                        dic[n2[j]*n2[k]]=1
                    else:
                        dic[n2[j]*n2[k]]+=1
            for u in n1:
                if u*u in dic:
                    count+=dic[u*u]
            return count
        return typeone(nums1,nums2)+typeone(nums2,nums1)

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        t1 = defaultdict(int)
        t2 = defaultdict(int)
        ans = 0
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                t1[nums1[i]*nums1[j]] += 1
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                t2[nums2[i]*nums2[j]] += 1
                
        for n in nums1:
            ans += t2[n*n]
        for n in nums2:
            ans += t1[n*n]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from math import sqrt
        from collections import Counter
        def find(target, pool):
            ans = 0
            target = Counter(target)
            for i in range(0, len(pool)-1):
                for j in range(i + 1, len(pool)):
                    ans += target.get(sqrt(pool[i]*pool[j]), 0)
            return ans
        
        return find(nums1, nums2) + find(nums2, nums1)

def func(xs, ys):
    sqs = [x**2 for x in xs]
    seen = collections.defaultdict(int)
    res = 0
    for y in ys:
        for x in sqs:
            if x % y == 0:
                res += seen[x//y]
        seen[y] += 1
    
    return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return func(nums1, nums2) + func(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dic1 = {}
        dic2 = {}
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                v = nums1[i] * nums1[j]
                if dic1.get(v) is None:
                    dic1[v] = 1
                else:
                    dic1[v] = dic1[v]+1
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                v = nums2[i] * nums2[j]
                if dic2.get(v) is None:
                    dic2[v] = 1
                else:
                    dic2[v] = dic2[v]+1
        cnt = 0
        for v in nums1:
            if dic2.get(v*v):
                cnt += dic2.get(v*v)
        for v in nums2:
            if dic1.get(v*v):
                cnt += dic1.get(v*v)
        return cnt


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1=[x*x for x in nums1]
        n2=[x*x for x in nums2]
        dnum1=collections.Counter(n1)
        dnum2=collections.Counter(n2)                
        ans=0
        nums1.sort()
        nums2.sort()
        m1=max(dnum1.keys())
        m2=max(dnum2.keys())
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                comb=nums1[i]*nums1[j]
                if comb in dnum2:
                    ans+=dnum2[nums1[i]*nums1[j]]
                if comb>m2:
                    break
               
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                comb=nums2[i]*nums2[j]
                if comb in dnum1:
                    ans+=dnum1[nums2[i]*nums2[j]]
                if comb>m1:
                    break
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        Type1=dict()
        Product1=dict()
        Type2=dict()
        Product2=dict()
        for i in range(len(nums1)):
            product= nums1[i]*nums1[i]
            if product in Product1.keys():
                Product1[product]+=1
            else:
                Product1[product]=1
            for j in range(i+1, len(nums1)):
                new_product=nums1[i]*nums1[j]
                if new_product in Type1.keys():
                    Type1[new_product]+=1
                else:
                    Type1[new_product]=1
        for i in range(len(nums2)):
            product= nums2[i]*nums2[i]
            if product in Product2.keys():
                Product2[product]+=1
            else:
                Product2[product]=1
            for j in range(i+1, len(nums2)):
                new_product=nums2[i]*nums2[j]
                if new_product in Type2.keys():
                    Type2[new_product]+=1
                else:
                    Type2[new_product]=1
        res=0
        for i in Product1.keys():
            if i in Type2.keys():
                res+=Product1[i]*Type2[i]
        for i in Product2.keys():
            if i in Type1.keys():
                res+=Product2[i]*Type1[i]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        map1={}
        map2={}
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                prod=nums1[i]*nums1[j]
                map1.setdefault(prod,0)
                map1[prod]+=1
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                prod=nums2[i]*nums2[j]
                map2.setdefault(prod,0)
                map2[prod]+=1

        res=0
        for num in nums1:
            if num**2 in map2:
                res+=map2[num**2]
        for num in nums2:
            if num**2 in map1:
                res+=map1[num**2]
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        products1 = collections.defaultdict(int)
        products2 = collections.defaultdict(int)
        
        result = 0
        
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                p = nums1[i]*nums1[j]
                products1[p] += 1
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                p = nums2[i]*nums2[j]
                products2[p] += 1
        
        for num in nums1:
            result += products2[num*num]
        
        for num in nums2:
            result += products1[num*num]
        
        return result


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = self.findTriple(nums1, nums2)
        count += self.findTriple(nums2, nums1)
        
        return count
        
    def findTriple(self, nums1, nums2):
        counts = {}
        for num in nums2:
            if num not in counts:
                counts[num] = 0
            counts[num] += 1
        
        tcount = 0
        for i in range(0, len(nums1)):
            for j in range(0, len(nums2)):
                if nums2[j] < nums1[i] and (nums1[i] * nums1[i]) % nums2[j] == 0 and (nums1[i] * nums1[i]) // nums2[j] in counts:
                    tcount += counts[nums1[i] * nums1[i] // nums2[j]]
        
            if nums1[i] in counts:
                tcount += (counts[nums1[i]] * (counts[nums1[i]] - 1) // 2)
        
        return tcount


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        hash1=defaultdict(int)
        hash2=defaultdict(int)
        
        count =0
        for i in nums1:
            hash1[i*i]+=1
            
        for i in nums2:
            hash2[i*i]+=1
            
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                if(nums1[i]*nums1[j] in hash2):
                    count+=hash2[nums1[i]*nums1[j]]
                    
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                if(nums2[i]*nums2[j] in hash1):
                    count+= hash1[nums2[i]*nums2[j]]
        
        return count

class Solution:
    def numTriplets(self, a: List[int], b: List[int]) -> int:
        
        # i^2 / k == j
        
        def count(a, b):
            
            c = Counter()
            
            for x,y in combinations(b, 2):
                c[x*y] += 1
            
            ret = 0
            
            for x in a:
                ret += c[x*x]    
            
            return ret
        
        return count(a,b) + count(b,a)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def twoProd(n1, n2):
            d = Counter()
            for i, a in enumerate(n1):
                for j in range(i+1, len(n1)):
                    d[a*n1[j]] += 1
        
            return sum(d[i*i] for i in n2)
        
        return twoProd(nums1, nums2) + twoProd(nums2, nums1)        

class Solution:
    def wrapper(self, toSquare, toProd):
        
        #create a hash table of count of unique squared ints in arr 1
        table = {}
        for integer in toSquare:
            squared = integer**2
            if squared not in table:
                table[squared] = 1
            else:
                table[squared] += 1
        
        counter = 0
        #get all pairs products, check in hash table, if so, inc counter by count in table
        i = 0
        while i < len(toProd): #minus one ok too?
            j = i + 1
            while j < len(toProd):
                product = toProd[i] * toProd[j]
                if product in table:
                    counter += table[product]
                j += 1
            i += 1
        
        return counter
                    
    def numTriplets1(self, nums1: List[int], nums2: List[int]) -> int:
        
        counter = 0
        counter += self.wrapper(nums1, nums2)
        counter += self.wrapper(nums2, nums1)
        return counter
    
    def get_tables(self, nums):
        squares = {}
        products = {}
        i = 0
        while i != len(nums):
            j = i
            while j != len(nums):   # O(N^2)
                product_or_square = nums[i] * nums[j]
                if i == j:
                    if product_or_square not in squares:    # O(1)
                        squares[product_or_square] = 1     # O(1) 
                    else:
                        squares[product_or_square] += 1     # O(1)
                else:
                    if product_or_square not in products:
                        products[product_or_square] = 1
                    else:
                        products[product_or_square] += 1
                j += 1
            i += 1
        
        return products, squares
    
    def get_counts(self, products, squares):
        # iterate over the smaller set
        counter = 0
        if len(products) > len(squares):
            for square in squares:          # O(N)
                if square in products:
                    counter += squares[square] * products[square]
        else:
            for product in products:        #O(M)
                if product in squares:
                    counter += products[product] * squares[product]
        
        return counter
    
    def numTriplets2(self, nums1: List[int], nums2: List[int]) -> int:
        products1, squares1 = self.get_tables(nums1)
        products2, squares2 = self.get_tables(nums2)
        counter = 0
        counter += self.get_counts(products1, squares2)
        counter += self.get_counts(products2, squares1)

        return counter
    
    def get_products(self, nums):
        table = {}
        i = 0
        while i < len(nums) - 1:
            j = i + 1
            while j < len(nums):
                prod = nums[i] * nums[j]
                if prod not in table:
                    table[prod] = 1
                else:
                    table[prod] += 1
                j += 1
            i += 1
        
        return table
    
    def check_squares_in_prods(self, nums, prods):
        counter = 0
        for i in nums:
            sq = i**2
            if sq in prods:
                counter += prods[sq]
        return counter
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        prods1 = self.get_products(nums1)
        prods2 = self.get_products(nums2)

        counter = 0
        counter += self.check_squares_in_prods(nums1, prods2)
        counter += self.check_squares_in_prods(nums2, prods1)
        
        return counter


class Solution:
    def helper(self,nums1,nums2):
        n1=len(nums1)
        n2=len(nums2)
        ans=0
        h1={}
        for j in range(n1):
            for k in range(j+1,n1):
                if nums1[j]*nums1[k] not in h1:
                    h1[nums1[j]*nums1[k]]=1
                else:
                    h1[nums1[j]*nums1[k]]+=1
                    
                    
        l=[i**2 for i in nums2]
        
        
        ans=0
        for i in l:
            if i in h1:
                ans+=h1[i]
        return ans
    
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        return self.helper(nums1,nums2)+self.helper(nums2,nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        

        def multi(arr):
            D = {}
            for i in range(len(arr)):
                for j in range(i+1,len(arr)):
                    if arr[i] * arr[j] not in D:
                        D[arr[i] * arr[j]] = 1
                    else:
                        D[arr[i] * arr[j]] += 1
            return D
                    
        nums1_multi = multi(nums1)
        nums2_multi = multi(nums2)
        res = 0
        
        for i in nums1:
            res += nums2_multi.get(i**2,0)
            
        for i in nums2:
            res += nums1_multi.get(i**2,0)

        
        return res     



class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        num1_counts = collections.Counter(nums1)
        num2_counts = collections.Counter(nums2)
        res = 0
        
        def findMatches(d1, d2):
            res = 0
            for n1 in d1:
                square = n1*n1
                checked = set()
                for n2 in d2:
                    if n2 in checked or square%n2: continue

                    k = square//n2
                    if k == n2:
                        res += d1[n1]*d2[n2]*(d2[n2]-1)//2
                    elif k in d2:
                        res += d1[n1]*d2[n2]*d2[k]
                        checked.add(k)

                    checked.add(n2)
            return res
        
        return findMatches(num1_counts, num2_counts) + findMatches(num2_counts,num1_counts)
                    


class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        
        countA = defaultdict(int)
        countB = defaultdict(int)
        
        for i in range(len(A)):
            for j in range(i + 1, len(A)):
                countA[A[i] * A[j]] += 1
        
        for i in range(len(B)):
            for j in range(i + 1, len(B)):
                countB[B[i] * B[j]] += 1
        
        res = 0
        for i in range(len(A)):
            val = A[i] ** 2
            res += countB[val]
            
        for i in range(len(B)):
            val = B[i] ** 2
            res += countA[val]
        
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def findTriplet2(arr1,arr2):
            result = 0
            m = len(arr2)
            count = collections.Counter([x**2 for x in arr1])
            for j in range(m):
                for k in range(j+1,m):
                    if arr2[j]*arr2[k] in list(count.keys()):
                        result += count[arr2[j]*arr2[k]]
            return result
        def findTriplet(arr1,arr2):
            n,m = len(arr1),len(arr2)
            triplets = 0
            for i in range(n):
                for j in range(m):
                    for k in range(j+1,m):
                        if arr1[i]**2 == arr2[j]*arr2[k]:
                            triplets += 1
            return triplets
        return findTriplet2(nums1,nums2)+findTriplet2(nums2,nums1)
        
        
        
    
    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        
        def numValid(target, nums):
            start, end = 0, len(nums) - 1
            ans = 0
            while start < end:
                if target * target == nums[start] * nums[end]:
                    if nums[start] == nums[end]:
                        n = end - start + 1
                        ans += n * (n - 1) // 2
                        break
                    else:
                        start += 1
                        end -= 1
                        dup1 = dup2 = 1
                        while start < end and nums[start - 1] == nums[start]:
                            start += 1
                            dup1 += 1
                        start -= 1
                        while start < end and nums[end] == nums[end + 1]:
                            end -= 1
                            dup2 += 1
                        ans += dup1 * dup2                    
                elif target * target < nums[start] * nums[end]:
                    end -= 1
                elif target * target > nums[start] * nums[end]:
                    start += 1
            return ans
        
        ans = 0
        for num1 in nums1:
            ans += numValid(num1, nums2)
        for num2 in nums2:
            ans += numValid(num2, nums1)
        return ans

class Solution(object):
    def numTriplets(self, A, B):
        from collections import Counter
        countA = Counter()
        countB = Counter()
        for i, x in enumerate(A):
            for j in range(i+1, len(A)):
                y = A[j]
                countA[x * y] += 1
        for i, x in enumerate(B):
            for j in range(i+1, len(B)):
                y = B[j]
                countB[x * y] += 1
        ans = 0
        for i, x in enumerate(A):
            ans += countB[x * x]
        for i, x in enumerate(B):
            ans += countA[x * x]
        return ans

class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        countA = Counter()
        countB = Counter()
        
        for i in range(len(A)):
            for j in range(i+1,len(A)):
                countA[ A[i]* A[j] ] +=1
                
        for i in range(len(B)):
            for j in range(i+1,len(B)):
                countB[ B[i]* B[j] ] +=1
                
        ans=0        
        for x in A:
            ans += countB[x*x]
            
        for x in B:
            ans += countA[x*x]
            
        return(ans)


from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sqr_num1 = Counter(x ** 2 for x in nums1)
        sqr_num2 = Counter(x ** 2 for x in nums2)
        len_num1, len_num2 = len(nums1), len(nums2)
        multi_num1, multi_num2 = Counter(), Counter()
        
        if len_num1 > 1:
            for i in range(len_num1 - 1):
                for j in range(i + 1, len_num1):
                    multi_num1[nums1[i] * nums1[j]] += 1
                    
        if len_num2 > 1:
            for i in range(len_num2 - 1):
                for j in range(i + 1, len_num2):
                    multi_num2[nums2[i] * nums2[j]] += 1
                    
        res = 0
        
        for n in sqr_num1:
            if n in multi_num2:
                res += sqr_num1[n] * multi_num2[n]
                
        for n in sqr_num2:
            if n in multi_num1:
                res += sqr_num2[n] * multi_num1[n]
                
        return res
                
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def check(A, B):
            n, res = len(B), 0
            C = Counter(map(lambda i: i*i, A))
            
            for i in range(n):
                for j in range(i+1, n):
                    res += C[B[i] * B[j]]
                    
            return res
        
        return check(nums1, nums2) + check(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def h(nums1, nums2):
            n = len(nums1)
            counter = collections.Counter()
            for i in range(n):
                for j in range(i + 1, n):
                    counter[nums1[i] * nums1[j]] += 1
            return sum(counter[i**2] for i in nums2)
        return h(nums1, nums2) + h(nums2, nums1)

class Solution:
    def numTriplets(self, A,B):
        countA = collections.Counter()
        countB = collections.Counter()
        for i in range(len(A)):
            for j in range(i+1,len(A)):
                countA[A[i]*A[j]] += 1
        
        for i in range(len(B)):
            for j in range(i+1,len(B)):
                countB[B[i]*B[j]] += 1
        ans = 0
        for x in A:
            ans += countB[x*x]
        for x in B:
            ans += countA[x*x]
        return ans
        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def get_sqs(nums):
            c = collections.Counter()
            for j in range(len(nums)):
                for k in range(j+1,len(nums)):
                    c[nums[j]*nums[k]]+=1
            return c
        
        sq1s = get_sqs(nums1)
        sq2s = get_sqs(nums2)
        
        res = 0
        
        for n in nums1:
            res+=sq2s[n*n]
        for n in nums2:
            res+=sq1s[n*n]
        
        return res

class Solution:
    def build_triplets(self, numbers1, numbers2):
        ret = 0
        
        
        for number1, occurrences1 in numbers1.items():
            number1 *= number1
            checked_numbers = set()
            
            
            for number2, occurrences2 in numbers2.items():
                if (number2 not in checked_numbers):
                    required = number1 // number2


                    if (required not in checked_numbers and required * number2 == number1
                        and required in numbers2):
                        if (required == number2):
                            ret += occurrences2 * occurrences1 * (occurrences1 - 1) // 2
                        else:
                            ret += occurrences2 * numbers2[required] * occurrences1

                        checked_numbers.add(required)
                        
        return ret
        
        
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        numbers1 = collections.Counter(nums1)
        numbers2 = collections.Counter(nums2)
        return self.build_triplets(numbers1, numbers2) + self.build_triplets(numbers2, numbers1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        m = len(nums2)
        nums2_pairs = Counter()
        nums1_pairs = Counter()
        
        for i in range(n):
            for j in range(i+1, n):
                nums1_pairs[nums1[i]*nums1[j]] += 1
        
        for i in range(m):
            for j in range(i+1, m):
                nums2_pairs[nums2[i]*nums2[j]] += 1

        ans = 0
        for i in range(n):
            ans += nums2_pairs[nums1[i]*nums1[i]]
        for i in range(m):
            ans += nums1_pairs[nums2[i]*nums2[i]]
        return ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(a,b):
            ans = 0
            hashm = {}
            for i in a:
                if i*i not in hashm:
                    hashm[i*i] = 1
                else:
                    hashm[i*i] = hashm[i*i]+1
            for i in range(len(b)):
                for j in range(i+1,len(b)):
                    if b[i]*b[j] in hashm:
                        ans = ans+ hashm[b[i]*b[j]]
            return ans
        return helper(nums1,nums2) + helper(nums2,nums1)

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        mul1, mul2 = Counter(), Counter()
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                mul1[nums1[i]*nums1[j]] += 1
        
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                mul2[nums2[i]*nums2[j]] += 1
        
        tots = 0
        for i in range(len(nums1)):
            tots+= mul2[nums1[i]**2]
        for i in range(len(nums2)):
            tots+= mul1[nums2[i]**2]
        return tots
            


class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        def getTriplets(A, B):
            m, n = len(A), len(B)
            ans = 0
            counter = Counter()
            for j in range(n):
                for k in range(j+1,n):
                    prod = B[j]*B[k]
                    counter[prod] += 1
            for i in range(m):
                prod = A[i]**2
                ans += counter[prod]
            return ans 
        return getTriplets(A,B) + getTriplets(B,A)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        rep=0
        rep+=self.getNumTriplets(nums1,nums2)
        rep+=self.getNumTriplets(nums2,nums1)
        return rep
    
    def getNumTriplets(self,nums1,nums2):
        num1=[n**2 for n in nums1]
        num2=[]
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                num2.append(nums2[i]*nums2[j])
        num2.sort()
        num1.sort()
        
        rep=0
        k=0
        while k<len(num1):
            cur=self.exist(num2,num1[k])
            rep+=cur
            while k+1<len(num1) and num1[k+1]==num1[k]:
                rep+=cur
                k+=1
            k+=1
        return rep
    
    def exist(self,nums,target):
        l=0
        r=len(nums)-1
        while l<=r:
            mid=l+(r-l)//2
            if nums[mid]>target:
                r=mid-1
            elif nums[mid]<target:
                l=mid+1
            else: # nums[mid]==target
                l=self.leftSearch(nums[:mid+1],target)
                r=self.rightSearch(nums[mid:],target)+mid
                return r-l+1
        return 0
    
    def leftSearch(self,nums,target):
        l,r=0,len(nums)-1
        while l<=r:
            mid=l+(r-l)//2
            if nums[mid]==target:
                r=mid-1
            else:
                l=mid+1
        return l
    
    def rightSearch(self,nums,target):
        l,r=0,len(nums)-1
        while l<=r:
            mid=l+(r-l)//2
            if nums[mid]==target:
                l=mid+1
            else:
                r=mid-1
        return r

class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        def getTriplets(A, B):
            m, n = len(A), len(B)
            ans = 0
            counter = Counter()
            for j in range(n):
                for k in range(j+1,n):
                    prod = B[j]*B[k]
                    counter[prod] += 1
            for i in range(m):
                prod = A[i]**2
                ans += counter[prod]
            return ans 
        return getTriplets(A,B) + getTriplets(B,A)            
                    
            


class Solution:
    def wrapper(self, toSquare, toProd):
        
        #create a hash table of count of unique squared ints in arr 1
        table = {}
        for integer in toSquare:
            squared = integer**2
            if squared not in table:
                table[squared] = 1
            else:
                table[squared] += 1
        
        counter = 0
        #get all pairs products, check in hash table, if so, inc counter by count in table
        i = 0
        while i < len(toProd): #minus one ok too?
            j = i + 1
            while j < len(toProd):
                product = toProd[i] * toProd[j]
                if product in table:
                    counter += table[product]
                j += 1
            i += 1
        
        return counter
                    
    def numTriplets1(self, nums1: List[int], nums2: List[int]) -> int:
        
        counter = 0
        counter += self.wrapper(nums1, nums2)
        counter += self.wrapper(nums2, nums1)
        return counter
    
    def get_tables(self, nums):
        squares = {}
        products = {}
        i = 0
        while i != len(nums):
            j = i
            while j != len(nums):
                product_or_square = nums[i] * nums[j]
                if i == j:
                    if product_or_square not in squares:
                        squares[product_or_square] = 1
                    else:
                        squares[product_or_square] += 1
                else:
                    if product_or_square not in products:
                        products[product_or_square] = 1
                    else:
                        products[product_or_square] += 1
                j += 1
            i += 1
        
        return products, squares
    
    def get_counts(self, products, squares):
        # iterate over the smaller set
        counter = 0
        if len(products) > len(squares):
            for square in squares:
                if square in products:
                    counter += squares[square] * products[square]
        else:
            for product in products:
                if product in squares:
                    counter += products[product] * squares[product]
        
        return counter
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        products1, squares1 = self.get_tables(nums1)
        products2, squares2 = self.get_tables(nums2)
        counter = 0
        counter += self.get_counts(products1, squares2)
        counter += self.get_counts(products2, squares1)

        return counter


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import Counter
        m, n = len(nums1), len(nums2)
        res = 0

        pool2 = Counter()
        for i in range(n - 1):
            for j in range(i + 1, n):
                curr = nums2[i] * nums2[j]
                pool2[curr] += 1

        for v in nums1:
            curr = v ** 2
            if curr in pool2:
                res += pool2[curr]

        pool1 = Counter()
        for i in range(m - 1):
            for j in range(i + 1, m):
                curr = nums1[i] * nums1[j]
                pool1[curr] += 1

        for v in nums2:
            curr = v ** 2
            if curr in pool1:
                res += pool1[curr]

        return res

def func(xs, ys):
    sqs = [x**2 for x in xs]
    seen = collections.defaultdict(int)
    res = 0
    for y in ys:
        for x in sqs:
            res += seen[x/y]
        seen[y] += 1
    
    return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return func(nums1, nums2) + func(nums2, nums1)

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(A, B):
            ans = 0
            C = Counter([a*a for a in A])
            D = Counter()
            for b in B:
                for k, v in D.items():
                    if k*b in C:
                        ans += v * C[k*b]
                D[b] += 1
            return ans
        
        return helper(nums1, nums2) + helper(nums2, nums1)

import math
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        cnt=0
        d={}
        ans=0
        for i in range(0,len(nums2)):
            for j in range(i+1,len(nums2)):
                if(i!=j):
                    p=(nums2[i]*nums2[j])
                    try:
                        d[p]+=1
                    except:
                        d[p]=1
        #print(d)
        for i in range(0,len(nums1)):
            p=nums1[i]*nums1[i]
            try:
                if(d[p]>0):
                    cnt=cnt+d[p]
            except:
                ans=1
        d={}
        for i in range(0,len(nums1)):
            for j in range(i+1,len(nums1)):
                if(i!=j):
                    p=(nums1[i]*nums1[j])
                    try:
                        d[p]+=1
                    except:
                        d[p]=1
        for i in range(0,len(nums2)):
            p=nums2[i]*nums2[i]
            try:
                if(d[p]>0):
                    cnt=cnt+d[p]
            except:
                ans=1
        return cnt
                
        
                        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] 
        # (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] 
    
        n = len(nums1)
        m = len(nums2)
        n2dict = defaultdict(int)
        m2dict = defaultdict(int)
        for x in nums1:
            n2dict[x*x]+=1
        for x in nums2:
            m2dict[x*x]+=1
        # n2 = [x*x for i,x in enumerate(nums1)]
        # n2c= Counter(n2)
        # m2 = [x*x for i,x in enumerate(nums2)]
        # m2c= Counter(m2)
        out = 0
        
       #print(n2, m2)
        #print(n2c, m2c)
            
        for i in range(m):
            for j in range(i+1, m):
                key = nums2[i] * nums2[j]
                #print(key)
                if nums2[i] * nums2[j] in n2dict:
                    out += (n2dict[key])
                    #print(key, nums2[i], nums2[j])
                    
        #print()
        for i in range(n):
            for j in range(i+1, n):
                key = nums1[i] * nums1[j]
                
                #print(key)
                if key in m2dict:
                    out += (m2dict[key])
                    #print(key, nums1[i], nums1[j])
                    
        return out
        
        


from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        h1=defaultdict(list)
        h2=defaultdict(list)
        n=len(nums1)
        m=len(nums2)
        ans=0
        for i in range(n):
            for j in range(i+1,n):
                h1[nums1[i]*nums1[j]].append((i,j))
        for i in range(m):
            for j in range(i+1,m):
                h2[nums2[i]*nums2[j]].append((i,j))
        for i in range(n):
            if nums1[i]**2 in h2:
                ans+=len(h2[nums1[i]**2])
        for i in range(m):
            if nums2[i]**2 in h1:
                ans+=len(h1[nums2[i]**2])
        return ans
        
                


class Solution:
    def wrapper(self, toSquare, toProd):
        
        #create a hash table of count of unique squared ints in arr 1
        table = {}
        for integer in toSquare:
            squared = integer**2
            if squared not in table:
                table[squared] = 1
            else:
                table[squared] += 1
        
        counter = 0
        #get all pairs products, check in hash table, if so, inc counter by count in table
        i = 0
        while i < len(toProd): #minus one ok too?
            j = i + 1
            while j < len(toProd):
                product = toProd[i] * toProd[j]
                if product in table:
                    counter += table[product]
                j += 1
            i += 1
        
        return counter
                    
    def numTriplets1(self, nums1: List[int], nums2: List[int]) -> int:
        
        counter = 0
        counter += self.wrapper(nums1, nums2)
        counter += self.wrapper(nums2, nums1)
        return counter
    
    def get_tables(self, nums):
        squares = {}
        products = {}
        i = 0
        while i != len(nums):
            j = i
            while j != len(nums):
                product_or_square = nums[i] * nums[j]
                if i == j:
                    if product_or_square not in squares:
                        squares[product_or_square] = 1
                    else:
                        squares[product_or_square] += 1
                else:
                    if product_or_square not in products:
                        products[product_or_square] = 1
                    else:
                        products[product_or_square] += 1
                j += 1
            i += 1
        
        return products, squares
    
    def get_counts(self, products, squares):
        # iterate over the smaller set
        counter = 0
        if len(products) > len(squares):
            for square in list(squares.keys()):
                if square in products:
                    counter += squares[square] * products[square]
        else:
            for product in list(products.keys()):
                if product in squares:
                    counter += products[product] * squares[product]
        
        return counter
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        products1, squares1 = self.get_tables(nums1)
        products2, squares2 = self.get_tables(nums2)
        counter = 0
        counter += self.get_counts(products1, squares2)
        counter += self.get_counts(products2, squares1)

        return counter


from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        output = 0
        sq1 = Counter(map(lambda q: q*q, nums1))
        sq2 = Counter(map(lambda q: q*q, nums2))
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                output += sq1[nums2[i]*nums2[j]]
 
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                output += sq2[nums1[i]*nums1[j]]
                
        return output

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1, d2 = dict(), dict()

        for idx, n1 in enumerate(nums1):
            d1[idx] = dict()
            for elm in nums1[idx+1:]:
                try:
                    d1[idx][elm] += 1
                except KeyError:
                    d1[idx][elm] = 1

        for idx, n2 in enumerate(nums2):
            d2[idx] = dict()
            for elm in nums2[idx+1:]:
                try:
                    d2[idx][elm] += 1
                except KeyError:
                    d2[idx][elm] = 1
                    
        
        good_dict = {}
        for n1 in nums1:
            if (1, n1) not in good_dict:
                good = 0
                for idx, n2 in enumerate(nums2):
                    try:
                        good += d2[idx][n1**2/n2]
                    except KeyError:
                        pass
                good_dict[(1, n1)] = [good, 1]
            else:
                good_dict[(1, n1)][-1] += 1
                
        for n2 in nums2:
            if (2, n2) not in good_dict:
                good = 0
                for idx, n1 in enumerate(nums1):
                    try:
                        good += d1[idx][n2**2/n1] 
                    except KeyError:
                        pass
                good_dict[(2, n2)] = [good, 1]
            else:
                good_dict[(2, n2)][-1] += 1
        
        return sum(val*q for val, q in list(good_dict.values()))
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def fun(arr):
            res={}
            for i in range(len(arr)-1):
                for j in range(i+1,len(arr)):
                    if arr[i]*arr[j] in res.keys():
                        res[arr[i]*arr[j]] +=1
                    else:
                        res[arr[i]*arr[j]] =1
            return res
        
        x= fun(nums1)
        y= fun(nums2)
        res = 0
        for i in range(len(nums1)):
            if nums1[i]**2 in y.keys():
                print(nums1[i])
                res+=y[nums1[i]**2]
        
        for i in range(len(nums2)):
            if nums2[i]**2 in x.keys():
                res+=x[nums2[i]**2]
                       
        return res

import itertools
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dicA={}
        dicB={}
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                if nums1[i]*nums1[j] in dicA:
                    dicA[nums1[i]*nums1[j]]+=1
                else:
                    dicA[nums1[i]*nums1[j]]=1
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                if nums2[i]*nums2[j] in dicB:
                    dicB[nums2[i]*nums2[j]]+=1
                else:
                    dicB[nums2[i]*nums2[j]]=1
        ans=0
        for i in range(len(nums1)):
            try:
                val=dicB[nums1[i]*nums1[i]]
                ans+=val
            except KeyError:
                pass
        for i in range(len(nums2)):
            try:
                val=dicA[nums2[i]*nums2[i]]
                ans+=val
            except KeyError:
                pass
        return ans
            

        
            
                    


from collections import Counter
class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        def getTriplets(A, B):
            m, n = len(A), len(B)
            ans = 0
            counter = Counter()
            for j in range(n):
                for k in range(j+1,n):
                    prod = B[j]*B[k]
                    counter[prod] += 1
            for i in range(m):
                prod = A[i]**2
                ans += counter[prod]
            return ans 
        return getTriplets(A,B) + getTriplets(B,A)

import collections

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        counts1 = collections.Counter(nums1)
        counts2 = collections.Counter(nums2)
        print(counts1)
        print(counts2)
        
        def doit(c1,c2):
            total = 0
            for k1 in c1:
                for k2 in c2:
                    neededK = (k1 * k1) / k2
                    if neededK == int(neededK):
                        neededK = int(neededK)
                        if k2 == neededK:
                            i = c2[neededK]
                            j = (i-1 + 1) * (i-1) // 2
                            total += c1[k1] * j 
                        elif k2 < neededK:
                            total += c1[k1]*c2[k2]*c2[neededK]
                        print(k1,k2,neededK,total)
            return total
        
        return doit(counts1,counts2) + doit(counts2,counts1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1, lookup2, res = {}, {}, 0
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                if nums1[i]*nums1[j] in lookup1:
                    lookup1[nums1[i]*nums1[j]] += 1
                else:
                    lookup1[nums1[i]*nums1[j]] = 1
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                if nums2[i]*nums2[j] in lookup2:
                    lookup2[nums2[i]*nums2[j]] += 1
                else:
                    lookup2[nums2[i]*nums2[j]] = 1
        
        for i in nums1:
            if i*i in lookup2:
                res += lookup2[i*i]
        
        for i in nums2:
            if i*i in lookup1:
                res += lookup1[i*i]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        n1 = len(nums1)
        n2 = len(nums2)
        
        nums1_product = defaultdict(int)
        nums2_product = defaultdict(int)
        
        # count pairs for product
        for i in range(n1-1):
            for j in range(i+1, n1):
                nums1_product[(nums1[i] * nums1[j])] += 1
        
        for i in range(n2-1):
            for j in range(i+1, n2):
                nums2_product[(nums2[i] * nums2[j])] += 1
        
        for num1 in nums1:
            target = num1 ** 2
            
            ans += nums2_product[target]
        
        for num2 in nums2:
            target = num2 ** 2
            
            ans += nums1_product[target]
  
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1, lookup2 = collections.defaultdict(int), collections.defaultdict(int)
        for n in nums1:
            lookup1[n] += 1
        for n in nums2:
            lookup2[n] += 1
        res = 0
        for k in [0, 1]:
            nums = nums1 if not k else nums2
            lookup = lookup1 if k else lookup2
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    prod = nums[i] * nums[j]
                    k = int(math.sqrt(prod))
                    if k * k == prod and k in lookup:
                        res += lookup[k]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ct=0
        d={}
        for j in range(len(nums2)):
            for k in range(j+1,len(nums2)):
                if nums2[j]*nums2[k] in d:
                    d[nums2[j]*nums2[k]]=d[nums2[j]*nums2[k]]+1
                else:
                    d[nums2[j]*nums2[k]]=1
        dd={}
        for j in range(len(nums1)):
            for k in range(j+1,len(nums1)):
                if nums1[j]*nums1[k] in dd:
                    dd[nums1[j]*nums1[k]]=dd[nums1[j]*nums1[k]]+1
                else:
                    dd[nums1[j]*nums1[k]]=1
        
        ct=0       
        for i in range(len(nums1)):
            x=nums1[i]*nums1[i]
            if x in d:
                ct=ct+d[x]
            
        for i in range(len(nums2)):
            x=nums2[i]*nums2[i]
            if x in dd:
                ct=ct+dd[x]
        return ct


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        m1_square,m2_square={},{}
        for x in nums1:
            x_square = x**2
            m1_square[x_square]=m1_square.get(x_square,0)+1
            
        for x in nums2:
            x_square=x**2
            m2_square[x_square]=m2_square.get(x_square,0)+1
        
        m,n=len(nums1),len(nums2)
        ans = 0
        for j in range(m-1):
            for k in range(j+1,m):
                if (nums1[j]*nums1[k]) in m2_square:
                    ans+=m2_square[nums1[j]*nums1[k]]
        for j in range(n-1):
            for k in range(j+1, n):
                if (nums2[j]*nums2[k]) in m1_square:
                    ans+=m1_square[nums2[j]*nums2[k]]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        m1 = collections.defaultdict(int)
        m2 = collections.defaultdict(int)
        for i, num in enumerate(nums1):
            m1[num] += 1
        for i, num in enumerate(nums2):
            m2[num] += 1            
        self.ans = 0
        
        def count(nums : List[int], m: dict) -> None:
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    prod = nums[i] * nums[j]
                    sqrt = math.sqrt(prod)
                    if sqrt in m:
                        self.ans += m[sqrt]
        count(nums1, m2)
        count(nums2, m1)
        return self.ans


import collections
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        numsproddict=collections.defaultdict(int)
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                numsproddict[nums1[i]*nums1[j]]+=1
        numsproddict2=collections.defaultdict(int)
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                numsproddict2[nums2[i]*nums2[j]]+=1
        ans=0
        for i in range(len(nums1)):
            ans+=numsproddict2[nums1[i]*nums1[i]]
        for i in range(len(nums2)):
            ans+=numsproddict[nums2[i]*nums2[i]]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        squares1 = Counter()
        squares2 = Counter()
        for num in nums1:
            squares1[num*num] += 1
        for num in nums2:
            squares2[num*num] += 1
        
        numTriplets = 0
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                if nums1[i] * nums1[j] in squares2:
                    numTriplets += squares2[nums1[i] * nums1[j]]
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                if nums2[i] * nums2[j] in squares1:
                    numTriplets += squares1[nums2[i] * nums2[j]]
        return numTriplets

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from math import sqrt
        from collections import Counter
        def find(target, pool):
            ans = 0
            target = Counter(target)
            for i in range(0, len(pool)-1):
                for j in range(i + 1, len(pool)):
                    # print(sqrt(pool[i]*pool[j]))
                    if sqrt(pool[i]*pool[j]) in target:
                        ans += target[sqrt(pool[i]*pool[j])]
            return ans
        
        return find(nums1, nums2) + find(nums2, nums1)

from collections import defaultdict
class Solution:
    
    def getNumOfMatch(self,square,nums):
        res = 0
        h = defaultdict(int)
        n = len(nums)
        for v in nums:
            if square % v == 0:
                res += h[square//v]
                h[v] += 1
        return res
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        
        for num in nums1:
            res += self.getNumOfMatch(num*num,nums2)
        for num in nums2:
            res += self.getNumOfMatch(num*num,nums1)
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from math import sqrt
        from collections import Counter
        def find(target, pool):
            ans = 0
            target = Counter(target)
            for i in range(0, len(pool)-1):
                for j in range(i + 1, len(pool)):
                    if sqrt(pool[i]*pool[j]) in target:
                        ans += target[sqrt(pool[i]*pool[j])]
            return ans
        
        return find(nums1, nums2) + find(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1={}
        d2={}
        cnt1,cnt2=0,0
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                if nums1[i]*nums1[j] not in d1:
                    d1[nums1[i]*nums1[j]]=1
                else:
                    d1[nums1[i]*nums1[j]]+=1
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                if  nums2[i]*nums2[j] not in d2:
                    d2[nums2[i]*nums2[j]]=1
                else:
                    d2[nums2[i]*nums2[j]]+=1
        for i in range(len(nums1)):
            if nums1[i]**2 in d2:
                cnt1+=d2[nums1[i]**2]
        for i in range(len(nums2)):
            if nums2[i]**2 in d1:
                cnt2+=d1[nums2[i]**2]
        return cnt1+cnt2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        sums = {}
        sums2 = {}
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                if nums2[i]*nums2[j] in sums:
                    sums[nums2[i]*nums2[j]] += 1
                else:
                    sums[nums2[i]*nums2[j]] = 1
        for i in nums1:
            if i**2 in sums:
                result += sums[i**2]
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                if nums1[i]*nums1[j] in sums2:
                    sums2[nums1[i]*nums1[j]] += 1
                else:
                    sums2[nums1[i]*nums1[j]] = 1
        for i in nums2:
            if i**2 in sums2:
                result += sums2[i**2]
        return result

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import Counter
        
        c1 = Counter()
        c2 = Counter()
        r1 = 0
        r2 = 0
        for i in range(len(nums1)):
            for j in range(len(nums1)):
                if i<j:
                    c1[nums1[i]*nums1[j]]+= 1
                    
        for i in range(len(nums2)):
            for j in range(len(nums2)):
                if i<j:
                    c2[nums2[i]*nums2[j]]+= 1
                    
        for i in nums2:
            r1 += c1[i*i]
        for i in nums1:
            r2+= c2[i*i]
        
        return r1+r2

import collections
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        square1 = [e ** 2 for e in nums1]
        target1 = collections.Counter(square1)
        for i in range(len(nums2) - 1):
            for j in range(i+1, len(nums2)):
                if nums2[i]*nums2[j] in target1:
                    count += target1[nums2[i]*nums2[j]]
        square2 = [e ** 2 for e in nums2]
        target2 = collections.Counter(square2)
        for i in range(len(nums1) - 1):
            for j in range(i+1, len(nums1)):
                if nums1[i]*nums1[j] in target2:
                    count += target2[nums1[i]*nums1[j]]
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        rev, n1, n2 = 0, Counter(nums1), Counter(nums2)
        
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                t = (nums1[i] * nums1[j]) ** (1/2)
                
                if t == int(t) and t in n2:
                    rev += n2[t]
        
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                t = (nums2[i] * nums2[j]) ** (1/2)
                
                if t == int(t) and t in n1:
                    rev += n1[t]
        
        return rev

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        hh=defaultdict(int)
        nums1.sort()
        for m,i in enumerate(nums1):
            hh[i*i]+=1
        h=defaultdict(int)
        for i in nums2:
            h[i]+=1
        r=0
        print(h)
        for i in h:
            for j in h:
                if i<=j and i*j in hh:
                    if i==j:
                        r+=h[i]*(h[i]-1)//2*hh[i*j]
                    else:
                        r+=h[i]*h[j]*hh[i*j]
        nums1,nums2=nums2,nums1
        hh=defaultdict(int)
        nums1.sort()
        for m,i in enumerate(nums1):
            hh[i*i]+=1
        h=defaultdict(int)
        for i in nums2:
            h[i]+=1
        print(h)
        for i in h:
            for j in h:
                if i<=j and i*j in hh:
                    if i==j:
                        r+=h[i]*(h[i]-1)//2*hh[i*j]
                    else:
                        r+=h[i]*h[j]*hh[i*j]
        return r

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        double1, double2 = collections.Counter(), collections.Counter()
        for n in nums1:
            double1[n * n] += 1
        for n in nums2:
            double2[n * n] += 1
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                if nums1[i] * nums1[j] in double2:
                    res += double2[nums1[i] * nums1[j]]
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                if nums2[i] * nums2[j] in double1:
                    res += double1[nums2[i] * nums2[j]]
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dic1, dic2 = collections.Counter(nums1), collections.Counter(nums2)
        ans = 0
        m, n = len(nums1), len(nums2)
        for i in range(m):
            for j in range(i + 1, m):
                target = nums1[i] * nums1[j]
                sq = math.sqrt(target)
                if sq * sq == target:
                    ans += dic2[sq]
        for i in range(n):
            for j in range(i + 1, n):
                target = nums2[i] * nums2[j]
                sq = math.sqrt(target)
                if sq * sq == target:
                    ans += dic1[sq]
        
        return ans

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int: 
        mults = lambda arr, N: Counter([arr[i]*arr[j] for i in range(N) for j in range(N) if i != j])
        squares = lambda arr: list([x**2 for x in arr])
        
        count = 0
        A, B = squares(nums1), mults(nums2, len(nums2))
        C, D = squares(nums2), mults(nums1, len(nums1))
        for a in A:
            if a in B:
                count += B[a]
        
        for a in C:
            if a in D:
                count += D[a]
                
        return count // 2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        m1, m2 = collections.Counter(), collections.Counter()
        
        result = 0
        
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                n = sqrt(nums1[i] * nums1[j])
                if n % 1 == 0:
                    m1[n] += 1
                
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                n = sqrt(nums2[i] * nums2[j])
                if n % 1 == 0:
                    m2[n] += 1
        
        for num in nums1:
            result += m2[num]
        for num in nums2:
            result += m1[num]
        return result

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        squares1 = Counter([x ** 2 for x in nums1])
        squares2 = Counter([x ** 2 for x in nums2])
        total = 0
        
        # type 1
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                if (square := nums2[i] * nums2[j]) in squares1:
                    total += squares1[square]
                    
        # type 2
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                if (square := nums1[i] * nums1[j]) in squares2:
                    total += squares2[square]
        
        return total

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        m = len(nums1)
        n = len(nums2)
        
        
        mat2 = [[0 for i in range(n)] for i in range(n)] 
        def fillUpper(m,nums):
            mat = [[0 for i in range(m)] for i in range(m)]
            mapp1 = defaultdict(int)
            for i in range(m-1):
                for j in range(i+1,len(mat)):
                    # mat[i][j] = nums[i]**2 + nums[j]**2
                    mapp1[nums[i]*nums[j]]+=1
                    
            return  mapp1
        mat1 = fillUpper(m,nums1)
        mat2 = fillUpper(n,nums2)
        res = 0
        for i in nums1:
            c=i**2 
            if(c in mat2):
                res+=mat2[c]
        for i in nums2:
            c= i**2 
            if(c in mat1):
                res+=mat1[c]       
        return res


from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        product_set1, product_set2 = defaultdict(int), defaultdict(int)
        numss = [nums1, nums2]
        for n in range(2):
            if n == 0:
                s = product_set1
                # print(\"!\")
            else:
                s = product_set2
                # print(\"?\")
            nums = numss[n]
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    s[nums[i] * nums[j]] += 1
                    
        ans = 0
        # print(product_set1, product_set2)
        for n in range(2):
            if n == 0:
                s = product_set2
            else:
                s = product_set1
            nums = numss[n]
            for i in range(len(nums)):
                ans += s[nums[i] * nums[i]]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        total = 0
        
        nums1Sum = {}
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                nums1Sum[nums1[i] * nums1[j]] = nums1Sum.get(nums1[i] * nums1[j], 0) + 1
        
        nums2Sum = {}
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                nums2Sum[nums2[i] * nums2[j]] = nums2Sum.get(nums2[i] * nums2[j], 0) + 1
                
        for num in nums1:
            if num * num in nums2Sum:
                total += nums2Sum[num * num]
        
        for num in nums2:
            if num * num in nums1Sum:
                total += nums1Sum[num * num]
        
        return total

class Solution:
    def numTripletsHelper(self, nums1: List[int], nums2: List[int]) -> int:
        nums1_map = {}
        count = 0

        for i in nums1:
            if i in nums1_map:
                nums1_map[i] += 1
            else:
                nums1_map[i] = 1
        
        for i in nums2:
            i_2 = i * i
            seen = set({})
            for j in nums1:
                left = nums1_map[j]
                if i_2 / j == j:
                    if (j, j) not in seen and left > 1:
                        count += int((left * (left - 1)) / 2)
                        seen.add((j, j))
                elif i_2 / j in nums1_map and (int(i_2 / j), j) not in seen:
                    right = nums1_map[i_2 / j]
                    seen.add((int(i_2 / j), j))
                    seen.add((j, int(i_2 / j)))
                    count += left * right
        
        return count
        
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.numTripletsHelper(nums1, nums2) + self.numTripletsHelper(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import defaultdict
        import math
        n=len(nums1)
        m=len(nums2)
        dic1,dic2=defaultdict(int),defaultdict(int)
        for i in range(n):
            dic1[nums1[i]]+=1
        for i in range(m):
            dic2[nums2[i]]+=1
        ans=0
        for i in range(n):
            for j in range(i+1,n):
                x=nums1[i]*nums1[j]
                y=math.sqrt(x)
                if y%1==0:
                    # print(y,'y','nunms1',i,j)
                    ans+=dic2[y]
        for i in range(m):
            for j in range(i+1,m):
                x=nums2[i]*nums2[j]
                y=math.sqrt(x)
                if y%1==0:
                    # print(y,'y','nunms2')
                    ans+=dic1[y]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def check(l1, l2):
            res = {}
            j = 0
            while j < len(l2):
                k = j+1
                while k < len(l2):
                    res[l2[j] * l2[k]] = res.get(l2[j] * l2[k], 0) + 1
                    k += 1
                j += 1
            
            
            ans = 0
            while l1:
                node = l1.pop()
                if node in res:
                    ans += res[node]
            return ans

            
        squares1 = [x*x for x in nums1]
        squares2 = [x*x for x in nums2]
        return check(squares1, nums2) + check(squares2, nums1)

from collections import Counter
from typing import List


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0

        l1 = len(nums1)
        l2 = len(nums2)
        c1 = Counter()
        c2 = Counter()

        for j in range(l1):
            for k in range(j + 1, l1):
                c1[nums1[j] * nums1[k]] += 1

        for j in range(l2):
            for k in range(j + 1, l2):
                c2[nums2[j] * nums2[k]] += 1

        for i in range(l1):
            res += c2[nums1[i] * nums1[i]]

        for i in range(l2):
            res += c1[nums2[i] * nums2[i]]

        return res


class Solution:
    def numTriplets(self, num1: List[int], num2: List[int]) -> int:
        dic1={}
        for i in range(len(num1)):
            for j in range(i+1,len(num1)):
                if num1[i]*num1[j] in dic1:
                    dic1[num1[i]*num1[j]]+=1
                else:
                    dic1[num1[i]*num1[j]]=1
        dic2={}
        for i in range(len(num2)):
            for j in range(i+1,len(num2)):
                if num2[i]*num2[j] in dic2:
                    dic2[num2[i]*num2[j]]+=1
                else:
                    dic2[num2[i]*num2[j]]=1
        ans=0
        for i in num1:
            if i*i in dic2:
                ans+=dic2[i*i]
        for i in num2:
            if i*i in dic1:
                ans+=dic1[i*i]
        return ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(A, target):
            # print(A, target)
            l, r = 0, len(A) - 1
            ans = 0
            while l < r:
                s = A[l] * A[r]
                if s == target:
                    i = l + 1
                    while i < r and A[i] == A[l]:
                        i += 1
                    numL = i - l
                    j = r - 1
                    while j > l and A[j] == A[r]:
                        j -= 1
                    numR = r - j
                    l = i
                    r = j
                    if i > j and A[i] == A[j]:
                        ans += (r - l) * (r - l - 1) // 2
                    else:
                        ans += numL * numR
                    # print(ans)
                elif s < target:
                    l += 1
                else:
                    r -= 1
            return ans
        
        ans = 0
        nums1.sort()
        nums2.sort()
        for n in nums1:
            ans += find(nums2, n * n)
        for n in nums2:
            ans += find(nums1, n * n)
        return ans

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def solve(aa,bb):
            res=0
            cnt=defaultdict(int)
            for a in aa:
                for b in bb:
                    b2=b*b
                    if b2%a:continue
                    res+=cnt[b*b//a]
                cnt[a]+=1
            return res
        
        ans=solve(nums1,nums2)+solve(nums2,nums1)
        return ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import defaultdict
        if len(nums1) == 1 and len(nums2) == 1:
            return 0
        def twoproduct(nsquare,nums):
            countmap = defaultdict(int)
            total = 0
            for num in nums:
                if nsquare % num == 0:
                    total += countmap.get(nsquare//num,0)
                    countmap[num] += 1
            return total
        ans = 0
        for num in nums1:
            ans += twoproduct(num**2, nums2)
        for num in nums2:
            ans += twoproduct(num**2, nums1)
        return ans
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def getProd(n1, n2):
            c2 = Counter(n2)
            res = 0
            for x in n1:
                prod = x**2
                for n in n2:
                    if prod % n > 0: continue
                    d = prod // n
                    if d in c2:
                        res += c2[d]
                        #print(str(x) + \",\" + str(n) + \",\" + str(d))
                        if d == n: res -= 1
            return res
        r = 0
        r += getProd(nums1, nums2)
        r += getProd(nums2, nums1)
        return r//2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        rev, n1, n2 = 0, Counter(nums1), Counter(nums2)
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)
                if t == int(t) and t in n2:rev += n2[t]
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)
                if t == int(t) and t in n1:rev += n1[t]
        return rev

import bisect
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        v2i1,v2i2 = dict(), dict()
        n1, n2 = len(nums1), len(nums2)
        for i in range(0,n1):
            if not nums1[i] in v2i1:
                v2i1[nums1[i]] = []
            v2i1[nums1[i]].append(i)
            
        for i in range(0,n2):
            if not nums2[i] in v2i2:
                v2i2[nums2[i]] = []
            v2i2[nums2[i]].append(i) 
            
        result = 0
        
        for z in nums1:
            z = z*z
            for x in v2i2:
                if (z%x)==0 and (z//x) in v2i2:
                    y=z//x
                    if y!=x:
                        js, ks = v2i2[x], v2i2[y]
                        for j in js:
                            k = bisect.bisect(ks,j)
                            result += len(ks) - k
                    else:
                        result += len(v2i2[x])*(len(v2i2[x])-1)//2
        for z in nums2:
            z = z*z
            for x in v2i1:
                if (z%x)==0 and (z//x) in v2i1:
                    y=z//x
                    if y!=x:
                        js, ks = v2i1[x], v2i1[y]
                        for j in js:
                            k = bisect.bisect(ks,j)
                            result += len(ks) - k
                    else:
                        result += len(v2i1[x])*(len(v2i1[x])-1)//2
        return result

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        cnt1_e = Counter()
        cnt1_ne = Counter()
        
        for i in range(len(nums1)):
            cnt1_e[nums1[i]**2] += 1
            for j in range(i+1, len(nums1)):
                cnt1_ne[nums1[i]*nums1[j]] += 1
            
        cnt2_e = Counter()
        cnt2_ne = Counter()
        
        for i in range(len(nums2)):
            cnt2_e[nums2[i]**2] += 1
            for j in range(i+1, len(nums2)):
                cnt2_ne[nums2[i]*nums2[j]] += 1  
        res = 0
        for k1, v1 in list(cnt1_e.items()):
            if k1 in list(cnt2_ne.keys()):
                res += v1 * cnt2_ne[k1]
       
        for k2, v2 in list(cnt2_e.items()):
            if k2 in list(cnt1_ne.keys()):
                res += v2 * cnt1_ne[k2]
         
        return res
                    
            
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        triplets = 0
        n1 = Counter(nums1)
        n2 = Counter(nums2)
        
        for i in range(len(nums1) - 1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)
                if t == int(t) and t in n2:
                    triplets += n2[t]
                    
        for i in range(len(nums2) - 1):
            for j in range(i+1, len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)
                if t == int(t) and t in n1:
                    triplets += n1[t]
        
        return triplets
        
        


from collections import defaultdict


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        for num in nums1:
            res += self.two_product(num ** 2, nums2)
        for num in nums2:
            res += self.two_product(num ** 2, nums1)
        return res
    
    def two_product(self, target, nums):
        dic, res = defaultdict(int), 0
        for i, num in enumerate(nums):
            if target % num:
                continue
            remain = target // num
            res += dic[remain]
            dic[num] += 1
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        t1 = dict(collections.Counter(nums1))
        t2 = dict(collections.Counter(nums2))
        c = 0
        for j in range(len(nums1)):
            for k in range(j+1, len(nums1)):
                temp = math.sqrt(nums1[j] *nums1[k])
                if temp in t2:
                    c += t2[temp]
        for j in range(len(nums2)):
            for k in range(j+1, len(nums2)):
                temp = math.sqrt(nums2[j] *nums2[k])
                if temp in t1:
                    c += t1[temp]
        return c

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        rev, n1, n2 = 0, Counter(nums1), Counter(nums2)

        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)

                if t == int(t) and t in n2:
                    rev += n2[t]

        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)

                if t == int(t) and t in n1:
                    rev += n1[t]

        return rev

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        self.ans=0
        def func(n1, n2):
            for prod in n1:
                i, j = 0, len(n2)-1
                while i<j:
                    if n2[i]==n2[j]:
                            if n2[i]*n2[j]!=prod*prod:
                                break
                            n=j-i+1
                            self.ans+=(n*(n-1))//2
                            #print(self.ans)
                            break
                    #print(n2, i, j, prod*prod, n2[i], n2[j], n2[i]*n2[j])
                    if n2[i]*n2[j]==prod*prod:
                        temp=n2[i]
                        t1, t2=0, 0
                        while i<j and n2[i]==temp:
                            t1+=1
                            i+=1
                        temp=n2[j]
                        while i<=j and n2[j]==temp:
                            t2+=1
                            j-=1
                        self.ans+=(t1*t2)
                    elif n2[i]*n2[j]>prod*prod:
                        j-=1
                    else:
                        i+=1
        nums1.sort()
        nums2.sort()
        func(nums1, nums2)
        #print(self.ans)
        func(nums2, nums1)
        return self.ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        
        def count(arr,match):
            n=len(arr)
            cnt=0
            for i in range(n):
                for j in range(i+1,n):
                    val=math.sqrt(arr[i]*arr[j])
                   # print(val)
                    if match.get(val):
                        cnt+=match[val]
            return cnt
                    
            
        
        #square1,square2=collections.defaultdict(int),collections.defaultdict(int)
        #duplet1,duplet2=collections.defaultdict(int),collections.defaultdict(int)
        
        freq1,freq2=collections.Counter(nums1),collections.Counter(nums2)
        #Num1,Num2=list(freq1.keys()),list(freq2.keys())
       ## return 1
        return count(nums1,freq2)+count(nums2,freq1)
    
        
        


import bisect
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        v2i1,v2i2 = dict(), dict()
        n1, n2 = len(nums1), len(nums2)
        for i in range(0,n1):
            if not nums1[i] in v2i1:
                v2i1[nums1[i]] = []
            v2i1[nums1[i]].append(i)
            
        for i in range(0,n2):
            if not nums2[i] in v2i2:
                v2i2[nums2[i]] = []
            v2i2[nums2[i]].append(i) 
            
        result = 0
        
        for z in nums1:
            z = z*z
            for x in v2i2:
                if (z%x)==0 and (z//x) in v2i2:
                    y=z//x
                    if y!=x:
                        js, ks = v2i2[x], v2i2[y]
                        for j in js:
                            k = bisect.bisect_left(ks,j)
                            result += len(ks) - k
                    else:
                        result += len(v2i2[x])*(len(v2i2[x])-1)//2
        for z in nums2:
            z = z*z
            for x in v2i1:
                if (z%x)==0 and (z//x) in v2i1:
                    y=z//x
                    if y!=x:
                        js, ks = v2i1[x], v2i1[y]
                        for j in js:
                            k = bisect.bisect_left(ks,j)
                            result += len(ks) - k
                    else:
                        result += len(v2i1[x])*(len(v2i1[x])-1)//2
        return result

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        from collections import Counter
        
        C1 = Counter()
        
        C2 = Counter()
        
        for num in nums1:
            C1[num * num] += 1
        
        for num in nums2:
            C2[num * num] += 1
            
        res = 0
        
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                res += C2[nums1[i] * nums1[j]]
        
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                res += C1[nums2[i] * nums2[j]]
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1: List[int], nums2: List[int]) -> int:
            res = 0
            counter = Counter(nums2)
            for n1 in nums1:
                sq = n1 * n1
                for n2 in nums2:
                    if sq % n2 == 0:
                        num = sq / n2
                        res += counter[num]
                        if n1 == n2:
                            res -= 1
            return res
        
        return int((helper(nums1, nums2) + helper(nums2, nums1)) / 2)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        dict1 = dict()
        dict2 = dict()
        for x in nums1:
            if x in dict1:
                dict1[x] += 1
            else:
                dict1[x] = 1
        for x in nums2:
            if x in dict2:
                dict2[x] += 1
            else:
                dict2[x]=1
        for x in nums1:
            squar = x**2
            for y in nums2:
                if (squar/y) in dict2:
                    if (squar/y) == y:
                        result += dict2[squar/y] - 1
                    else:
                        result += dict2[squar/y]
        for x in nums2:
            squar = x**2
            for y in nums1:
                if (squar/y) in dict1:
                    if (squar/y) == y:
                        result += dict1[squar/y] - 1
                    else:
                        result += dict1[squar/y]  
        return int(result/2)                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        rev, n1, n2 = 0, Counter(nums1), Counter(nums2)

        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)

                if t == int(t) and t in n2:
                    rev += n2[t]

        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)

                if t == int(t) and t in n1:
                    rev += n1[t]

        return rev


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        d1 = collections.defaultdict(list)
        for i, num in enumerate(nums1):
            d1[num].append(i)
        
        for i in range(len(nums2) - 1):
            for j in range(i+1, len(nums2)):
                sqrt = (nums2[i]*nums2[j])**0.5
                if sqrt == int(sqrt) and sqrt in d1:
                    res += len(d1[sqrt])
        d2 = collections.defaultdict(list)
        for i, num in enumerate(nums2):
            d2[num].append(i)
        
        for i in range(len(nums1) - 1):
            for j in range(i+1, len(nums1)):
                sqrt = (nums1[i]*nums1[j])**0.5
                if sqrt == int(sqrt) and sqrt in d2:
                    res += len(d2[sqrt])
        return res

class Solution:
    def fact(self, n):   
        res = 1
        for i in range(2, n+1): 
            res = res * i 
        return res 

    def getCombo(self, n):
        return int(self.fact(n) / (self.fact(2)  
                * self.fact(n - 2))) 
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        #similar to the 2 sum problem- keep a dictionary for each list 
        d1 = {}
        for n in nums1:
            if n not in d1:
                d1[n] = 1
            else:
                d1[n]+=1
        d2 = {}
        for n in nums2:
            if n not in d2:
                d2[n] = 1
            else:
                d2[n]+=1
        tot = 0
        sq1 = 0
        
        for n in nums1:
            s = n*n
            for d in d2:
                if s%d == 0:
                    div = s//d
                    if div in d2:
                        if div == d:
                            sq1+=self.getCombo(d2[div])
                        else:
                            tot+=(d2[div]*d2[d])

        tot1 = tot//2
        tot = 0
        sq2 = 0
        for n in nums2:
            s = n*n
            for d in d1:
                if s%d == 0:
                    div = s//d
                    if div in d1:
                        if div == d:
                            sq2+=self.getCombo(d1[div])
                        else:
                            tot+=(d1[div]*d1[d])
        tot2 = tot//2
        return tot1+tot2+sq1+sq2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:

        nums1.sort()
        nums2.sort()

        def f(n):
            if n == 2 or n == 1:
                return 1
            return f(n - 1) + n - 1

        def yanzheng(a, num):
            '''
            接受一个数字a和一个有序列表num
            用动态规划算法验证是否存在num[i] * num[j] == a*a'''

            a = a * a
            head = 0
            end = len(num) - 1
            count = 0
            while True:
                headlen = 1
                endlen = 1
                if head >= end:
                    return count
                if num[head] * num[end] > a:
                    end -= 1
                elif num[head] * num[end] < a:
                    head += 1
                elif num[head] * num[end] == a:
                    if num[head] == num[end]:
                        count += f(end - head + 1)
                        head = end
                    elif num[head] == num[head + 1] or num[end] == num[end - 1]:
                        while num[head] == num[head + headlen]:
                            headlen += 1
                        while num[end] == num[end - endlen]:
                            endlen += 1
                        count += headlen * endlen
                        head += headlen
                        end -= endlen
                    else:
                        count += 1
                        end -= 1

        count = 0
        for i in nums1:
            count += yanzheng(i, nums2)
        for i in nums2:
            count += yanzheng(i, nums1)

        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        n1 = defaultdict(int)
        for n in nums1:
            n1[n] += 1
        n2 = defaultdict(int)
        for n in nums2:
            n2[n] += 1
        for j in range(len(nums1)):
            for k in range(j+1, len(nums1)):
                prod = nums1[j]*nums1[k]
                ans += n2[prod**0.5]
        for j in range(len(nums2)):
            for k in range(j+1, len(nums2)):
                prod = nums2[j]*nums2[k]
                ans += n1[prod**0.5]
        return ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        m = len(nums2)
        nums1prod = [[nums1[i]*nums1[j] for i in range(n)] for j in range(n)]
        nums2prod = [[nums2[i]*nums2[j] for i in range(m)] for j in range(m)]
        nums1sq = [x**2 for x in nums1]
        nums2sq = [x**2 for x in nums2]
        
        hm1sq = Counter(nums1sq)
        hm2sq = Counter(nums2sq)
        
        # print(hm1sq, hm2sq, nums1prod, nums2prod)
        
        trip = 0
        for i in range(n):
            for j in range(i+1,n):
                if nums1prod[i][j] in hm2sq:
                    # print(\"1\", hm2sq[nums1prod[i][j]], nums1prod[i][j])
                    trip+=hm2sq[nums1prod[i][j]]
        
        for i in range(m):
            for j in range(i+1,m):
                if nums2prod[i][j] in hm1sq:
                    # print(\"2\",hm1sq[nums2prod[i][j]], nums2prod[i][j])
                    trip+=hm1sq[nums2prod[i][j]]
                    
        return trip
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def getProd(nums):
            dict1 = {}
            for i in range(len(nums)):
                for j in range(len(nums)):
                    if i != j:
                        prod = nums[i] * nums[j]
                        if prod not in dict1:
                            dict1[prod] = 0
                        dict1[prod] += 1
            return dict1
        res = 0
        d1 = getProd(nums1)
        for x in nums2:
            if x**2 in d1:
                res += d1[x**2]
        d2 = getProd(nums2)
        for x in nums1:
            if x**2 in d2:
                res += d2[x**2]
        return res//2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def count(n1, n2):
            l2 = len(n2)
            cnt = Counter()
            for k in range(l2):
                for j in range(k):
                    v = n2[k] * n2[j]
                    cnt[v] += 1
            ans = 0
            for x in n1:
                ans += cnt[x*x]
            return ans
        
        return count(nums1, nums2) + count(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        jk_1 = {}
        for i in range(len(nums1)):
            for j in range(len(nums1)):
                if i!=j:
                    t = nums1[i]*nums1[j]
                    if t in jk_1:
                        jk_1[t]+=1
                    else: jk_1[t]=1
        jk_2 = {}
        for i in range(len(nums2)):
            for j in range(len(nums2)):
                if i!=j:
                    t = nums2[i]*nums2[j]
                    if t in jk_2:
                        jk_2[t]+=1
                    else: jk_2[t]=1
                        
                        
        #print(jk_1, jk_2)
        c=0
        for x in nums1:
            if x*x in jk_2:
                c+=jk_2[x*x]
        for x in nums2:
            if x*x in jk_1:
                c+=jk_1[x*x]
        return c//2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        
        triplets = 0
        
        for lst1, lst2 in (nums1, nums2), (nums2, nums1):
            for square in (n ** 2 for n in lst1):
                seen = defaultdict(int)
                for n in lst2:
                    if square % n == 0:
                        triplets += seen[square // n]
                    seen[n] += 1
                        
        return triplets
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        triplets = 0
        
        for lst1, lst2 in (nums1, nums2), (nums2, nums1):
            for square in (n ** 2 for n in lst1):
                seen = defaultdict(int)
                for n in lst2:
                    if square % n == 0:
                        triplets += seen[square // n]
                    seen[n] += 1
                        
        return triplets
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1, c2 = collections.Counter(nums1), collections.Counter(nums2)
        res = 0
        for n1 in nums1:
            x = n1 ** 2
            for n2 in nums2:
                if x % n2 == 0 and (x // n2) in c2:
                    if x // n2 == n2:
                        res += c2[x // n2] - 1
                    else:
                        res += c2[x // n2]
        for n2 in nums2:
            x = n2 ** 2
            for n1 in nums1:
                if x % n1 == 0 and (x // n1) in c1:
                    if x // n1 == n1:
                        res += c1[x // n1] - 1
                    else:
                        res += c1[x // n1]
        return res // 2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        
        def two(target, nums):
            counter = collections.defaultdict(int)
            res = 0
            for num in nums:
                if target % num == 0:
                    res += counter[target // num]
                counter[num] += 1
            return res
                    
            
        res = 0
        for num in nums1:
            res += two(num * num, nums2)
        for num in nums2:
            res += two(num * num, nums1)
            
        return res
            
        
        
#         counter1 = collections.Counter(nums1)
#         counter2 = collections.Counter(nums2)
#         nums1 = list(set(nums1))
#         nums1.sort()
#         nums2 = list(set(nums2))
#         nums2.sort()
        
#         def helper(nums, target, counter):
            
#             res = 0
#             seen = set()
#             for num in nums:
#                 if target % num == 0:
#                     if target // num == num:
#                         res += counter[num] * (counter[num]-1) // 2
#                     elif target // num in seen:
#                         res += counter[num] * counter[target//num]
#                 seen.add(num)
#             return res
                
        
#         def findTriplets(nums1, nums2, counter1, counter2):
#             res = 0
#             for num in nums1:
#                 target = num * num
#                 res += counter1[num] * helper(nums2, target, counter2)
#             return res
        
#         res = 0
#         res += findTriplets(nums1, nums2, counter1, counter2)
#         res += findTriplets(nums2, nums1, counter2, counter1)
#         return res
                
                
        
        
                
            
            
                
                
                
        
        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count1 = collections.Counter(nums1)
        count2 = collections.Counter(nums2)
        result = 0
        for num1 in count1:
            for num2 in count2:
                if num1**2 % num2 == 0 and num1**2 // num2 in count2:
                    target = num1**2 // num2
                    if target == num2:
                        if count2[num2] > 1:
                            result += count1[num1]*(count2[num2] * (count2[num2]-1) // 2)
                    else:
                        result += count1[num1]*(count2[num2] * count2[target] / 2)
        for num2 in count2:
            for num1 in count1:
                if num2**2 % num1 == 0 and num2**2 // num1 in count1:
                    target = num2**2 // num1
                    if target == num1:
                        if count1[num1] > 1:
                            result += count2[num2]*(count1[num1] * (count1[num1]-1) // 2)
                    else:
                        result += count2[num2]*(count1[num1] * count1[target] / 2)
        return int(result)

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        nums1_sq = [num**2 for num in nums1]
        nums2_sq = [num**2 for num in nums2]
        
        cache = defaultdict(int)
        count = 0
        
        for index in range(len(nums2)):
            number = nums2[index]
            if cache[number]:
                count += cache[number]
            for sub_index in range(len(nums1_sq)):
                square = nums1_sq[sub_index]
                q, r = divmod(square, number)
                if not r:
                    cache[q] += 1
        
        cache = defaultdict(int)
        
        for index in range(len(nums1)):
            number = nums1[index]
            if cache[number]:
                count += cache[number]
            for sub_index in range(len(nums2_sq)):
                square = nums2_sq[sub_index]
                q, r = divmod(square, number)
                if not r:
                    cache[q] += 1
        
        return count



class Solution:
    def find(self, n1, n2, c1):
        res = 0
        for j in range(len(n2)):
            for k in range(j+1, len(n2)):
                t = n2[j]*n2[k]
                sqrt = t**0.5
                if sqrt**2 != t:
                    continue
                try:
                    i = c1[sqrt]
                except KeyError:
                    i = 0
                res += i
        return res
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        n1 = set(nums1)
        n2 = set(nums2)
        c1 = {}
        c2 = {}
        for x in nums1:
            try:
                c1[x] += 1
            except KeyError:
                c1[x] = 1
        for x in nums2:
            try:
                c2[x] += 1
            except KeyError:
                c2[x] = 1
        res += self.find(nums1, nums2, c1)
        res += self.find(nums2, nums1, c2)
        return res

from collections import Counter
from itertools import combinations
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1, nums2):
            cnt = Counter()
            for a, b in combinations(nums1, 2):
                cnt[a * b] += 1
            return sum(cnt[x * x] for x in nums2)
        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def calculate(self, nums1, nums2):
        a = [0] * 100001
        for i in nums1:
            a[i] += 1
        ans = 0
        for num in nums2:
            for i in nums1:
                if num * num % i == 0 and num * num // i <= 100000:
                    ans += a[num * num // i]
                    if num == i:
                        ans -= 1
        ans = ans // 2
        return ans
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.calculate(nums1, nums2) + self.calculate(nums2, nums1)

from collections import defaultdict

class Solution:
    def numTriplets(self, num1: List[int], num2: List[int]) -> int:
        
        d11 = defaultdict(list)
        d12 = defaultdict(list)
        
        for i in range(len(num1)):
            for j in range(i, len(num1)):
                if i == j:
                    d11[num1[i]**2].append(i)
                else:
                    d12[num1[i]*num1[j]].append((i,j))
                    
        d21 = defaultdict(list)
        d22 = defaultdict(list)
        
        for i in range(len(num2)):
            for j in range(i, len(num2)):
                if i == j:
                    d21[num2[i]**2].append(i)
                else:
                    d22[num2[i]*num2[j]].append((i,j))
                    
        ans = 0
        
        for key in d11:
            if key in d22:
                ans += len(d11[key])*len(d22[key])
                
        for key in d21:
            if key in d12:
                ans += len(d21[key])*len(d12[key])
        
        return ans

class Solution:
    def numTriplets(self, a1: List[int], a2: List[int]) -> int:
        d={}
        n1=len(a1)
        n2=len(a2)
        for i in range(n1):
            for j in range(i+1,n1):
                if a1[i]*a1[j] in list(d.keys()):
                    d[a1[i]*a1[j]]+=1
                else:
                    d[a1[i]*a1[j]]=1
        c=0
        for x in a2:
            if x*x in list(d.keys()):
                c+=d[x*x]
        e={}
        for i in range(n2):
            for j in range(i+1,n2):
                if a2[i]*a2[j] in list(e.keys()):
                    e[a2[i]*a2[j]]+=1 
                else:
                    e[a2[i]*a2[j]]=1 
        
        for x in a1:
            if x*x in list(e.keys()):
                c+=e[x*x]
        
        return c
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        
        count = 0
        
        nums1m = [x * x for x in nums1]
        nums2m = [x * x for x in nums2]
        
        d1 = defaultdict(int)
        d2 = defaultdict(int)
        
        for num in nums1:
            d1[num] += 1
        for num in nums2:
            d2[num] += 1
        
        for num in nums1m:
            for j in range(len(nums2)):
                if nums2[j] > num:
                    break
                if num % nums2[j] != 0:
                    continue
                left = num // nums2[j] 
                
                if left in d2:
                    if left == nums2[j]:
                        count += d2[left] - 1
                    else:
                        count += d2[left]
                
        
        for num in nums2m:
            for j in range(len(nums1)):
                if nums1[j] > num:
                    break
                if num % nums1[j] != 0:
                    continue
                left = num // nums1[j]
                if left in d1:
                    if left == nums1[j]:
                        count += d1[left] - 1
                    else:
                        count += d1[left]
        
        return count//2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def one_type(nums1, nums2):
            res, counter = 0, collections.Counter(nums2)
            for num1 in nums1:
                prod = num1 * num1
                for num2 in nums2:
                    target = prod / num2
                    if target in counter:
                        res += counter[target] - (target == num1)
            return res // 2

        return one_type(nums1, nums2) + one_type(nums2, nums1)

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        c1 = Counter(nums1)
        c2 = Counter(nums2)
        for i in nums1:
            for j in nums2:
                j2 = j * j
                ji = j2 // i
                if ji * i == j2:
                    res += c1[j2 // i]
                    if ji == i:
                        res -= 1
                i2 = i * i
                ij = i2 // j
                if ij * j == i2:
                    res += c2[i2 // j]
                    if ij == j:
                        res -= 1
        return res // 2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1, d2 = {}, {}
        for i in range(len(nums1)):
            for j in range(i):
                d1[nums1[i] * nums1[j]] = d1.get(nums1[i] * nums1[j], 0) + 1
        for i in range(len(nums2)):
            for j in range(i):
                d2[nums2[i] * nums2[j]] = d2.get(nums2[i] * nums2[j], 0) + 1


        return sum(d1.get(i * i, 0) for i in nums2) + sum(d2.get(j * j, 0) for j in nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def helper(target,nums):
            dic=collections.defaultdict(int)
            count=0
            for num in nums:
                if target%num==0 and target//num in dic:
                    count+=dic[target//num]
                    
                dic[num]+=1
                
            return count
        
        ans=0
        for x in nums1:
            
            ans+=helper(x**2,nums2)
            
        for x in nums2:
            ans+=helper(x**2,nums1)
            
        return ans
            
                    
        
                
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def count(n, nums):
            cnt, d=0, collections.defaultdict(int)
            for i in nums:
                if n%i==0 and n//i in d: 
                    cnt+=d[n//i]
                d[i]+=1
            return cnt
        
        res=0
        for i in nums1:
            res+=count(i*i, nums2)
        for i in nums2:
            res+=count(i*i, nums1)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        fin = 0
        for i in range(len(nums1)):
            res = 0
            fin+= self.finder(nums1[i], nums2, res)
        for i in range(len(nums2)):
            res = 0
            fin+= self.finder(nums2[i], nums1, res)
        return fin
        
    def finder(self, square, arr,res):
        res = 0
        n = square*square
        di = {}
        for i in range(len(arr)):
            if n%arr[i]==0:
                p = n//arr[i]
                if arr[i] in di:
                    res+=di[arr[i]]
                if p in di:
                    di[p] += 1
                else:
                    di[p] = 1
                
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def twoProduct(arr, target):
            # returns the count of pairs in arr whose product equals target
            # twoProduct([2,3,1,3,4,6], 6) => 3
            d = {}
            ret = 0
            for x in arr:
                if target % x == 0 and target // x in d:
                    ret += d[target//x]
                if x in d:
                    d[x] += 1
                else:
                    d[x] = 1
            return ret

        ret = 0
        for x in nums1:
            sq = x**2
            ret += twoProduct(nums2, sq)
        for x in nums2:
            sq = x**2
            ret += twoProduct(nums1, sq)
        return ret

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def countTriplets(nums1,nums2):
            count = 0
            for index, val in enumerate(nums1):
                target = int(val**2)
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if (target / val2) in lookup:
                        count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(nums1,nums2):
            res=0
            for x in nums1:
                cnt=defaultdict(int)
                for y in nums2:
                    if (x*x)%y==0:
                        res+=cnt[(x*x)//y]
                    cnt[y]+=1
            return res
        ret=0
        ret+=find(nums1,nums2)
        ret+=find(nums2,nums1)
        return ret

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1= collections.Counter(nums1)
        c2= collections.Counter(nums2)
        r=0
        for n in nums1:
            for a in nums2:
                t = n*n//a

                if t*a == n*n:
                  
                    if t== a:
                        r= r+ (c2[t]-1)/2
                    else:
                        r= r+ c2[t]/2
        for a in nums1:
            for n in nums2:
                t= n*n//a
                if t*a == n*n:
                    if t== a:
                        r= r+ (c1[t]-1)/2
                    else:
                        r= r+ c1[t]/2
        return math.floor(r)
        
        
                        
                        
                            
                            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def twoProduct(target, nums):
            cnt = 0
            currMap = collections.defaultdict(lambda: 0)

            for num in nums:
                # 如果 target 整除 num2，且 target // num2 在 map 中，那么结果加上 map 中 target // num2 的个数
                if target % num == 0 and target // num in currMap:
                    cnt += currMap[target // num]

                currMap[num] += 1

            return cnt

        res = 0

        # 对于每一个 nums1 中的数，都创建一个 map
        for num1 in nums1:
            target = num1 * num1
            res += twoProduct(target, nums2)

        for num2 in nums2:
            target = num2 * num2
            res += twoProduct(target, nums1)

        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        d1={}
        d2={}
        for i in nums1:
            if i in d1:
                d1[i]+=1
            else:
                d1[i]=1
                
        for i in nums2:
            if i in d2:
                d2[i]+=1
            else:
                d2[i]=1
                
        count=0
        for key in d1:
            for x in d2:
                if (key**2)%x==0:
                    if (key**2)//x==x:
                        if d2[x]>1:
                            count+=d1[key]*(d2[x]-1)*(d2[x])
                    else:
                        if (key**2)//x in d2:
                            count+=d1[key]*(d2[x])*d2[(key**2)//x]
                            

        for key in d2:
            for x in d1:
                if (key**2)%x==0:
                    if (key**2)//x==x:
                        if d1[x]>1:
                            count+=d2[key]*(d1[x]-1)*(d1[x])
                    else:
                        if (key**2)//x in d1:
                            count+=d2[key]*(d1[x])*d1[(key**2)//x]
                            
        return count//2
                            
                        
                    
                    
                
        
        
        
        
        


from collections import defaultdict

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.triples(nums1, nums2) + self.triples(nums2, nums1)
        
        
    def triples(self, nums1, nums2):
        res = 0
        for n1 in nums1:
            visited = defaultdict(int)
            for n2 in nums2:
                if n1 * n1 % n2 == 0:
                    res += visited[n1 * n1 // n2]
                
                visited[n2] += 1
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        for num1 in nums1:
            currMap = collections.defaultdict(lambda: 0)
            target = num1 * num1

            for num2 in nums2:
                if target % num2 == 0 and target // num2 in currMap:
                    res += currMap[target // num2]

                currMap[num2] += 1

        for num2 in nums2:
            currMap = collections.defaultdict(lambda: 0)
            target = num2 * num2

            for num1 in nums1:
                if target % num1 == 0 and target // num1 in currMap:
                    res += currMap[target // num1]

                currMap[num1] += 1

        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def twoProd(B, sq):
            d = defaultdict(int)
            cnt = 0
            for val in B:
                if sq % val == 0:
                    cnt += d.get(sq // val, 0)
                d[val] += 1
            return cnt
        
        def poss(A, B):
            ret = 0
            m, n = len(A), len(B)
            for x in A:
                ret += twoProd(B, x * x)
            return ret
        
        return poss(nums1, nums2) + poss(nums2, nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1, n2 = Counter(nums1), Counter(nums2)
        
        rev = 0
        
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)
                
                if t == int(t) and t in n2:
                    rev += n2[t]
        
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)
                
                if t == int(t) and t in n1:
                    rev += n1[t]
        
        return rev

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        comp1, comp2 = defaultdict(set), defaultdict(set)
        
        if not nums1 or not nums2: return 0
        n, m = len(nums1), len(nums2)
        ans = 0
        
        c1, c2 = Counter([num**2 for num in nums1]), Counter([num**2 for num in nums2])
        
        for i in range(n):
            for j in range(i+1, n):
                prod = nums1[i]*nums1[j]
                ans += c2[prod]
                
        for i in range(m):
            for j in range(i+1, m):
                prod = nums2[i]*nums2[j]
                ans += c1[prod]
                
        return ans

from collections import defaultdict

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        self.res = 0
        
        def count(a1, a2):
            for e1 in [e * e for e in a1]:
                m = defaultdict(int)
                for e2 in a2:
                    if e1 % e2 == 0:
                        self.res += m[e1 // e2]
                    m[e2] += 1

        count(nums1, nums2)
        count(nums2, nums1)
        
        return self.res

from itertools import combinations
from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        num1Sq = [i*i for i in nums1]
        num2Sq = [i*i for i in nums2]
        c1 = Counter(num1Sq)
        c2 = Counter(num2Sq)
        
        comb1 = list(combinations(nums1, 2))    
        comb2 = list(combinations(nums2, 2))
        
        res = 0
        
        for i in comb1:
            res+=c2[i[0]*i[1]]
        
        for i in comb2:
            res+=c1[i[0]*i[1]]
        
        return res


def pairs(arr):
    for i in range(0, len(arr) - 1):
        for j in range(i + 1, len(arr)):
            yield (arr[i], arr[j])

def count(A, B):
    # Counts the number of triplets of type 1.
    
    tally_A = {}
    for elem in A:
        tally_A.setdefault(elem ** 2, 0)
        tally_A[elem ** 2] += 1
        
    tally_B = {}
    for e, f in pairs(B):
        tally_B.setdefault(e * f, 0)
        tally_B[e * f] += 1
        
    return sum(tally_A[e] * tally_B[e] for e in tally_A if e in tally_B)

class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        return count(A, B) + count(B, A)

from collections import Counter
from itertools import combinations
class Solution:
    def numTriplets(self, nums1, nums2) -> int:
        c_nums1 = Counter(nums1)
        c_nums2 = Counter(nums2)
        res = 0
        self_product1 = Counter()
        cross_product1 = Counter()
        self_product2 = Counter()
        cross_product2 = Counter()

        for k, v in c_nums1.items():
            self_product1[k**2] += v*(v-1)//2
        for k, v in c_nums2.items():
            self_product2[k**2] += v*(v-1)//2

        for comb in combinations(c_nums1.keys(), 2):
            p, v = comb
            cross_product1[p*v] += c_nums1[p]*c_nums1[v]
        for comb in combinations(c_nums2.keys(), 2):
            p, v = comb
            cross_product2[p*v] += c_nums2[p]*c_nums2[v]

        for k,v in c_nums1.items():
            target = k**2
            if target in cross_product2:
                res += v*cross_product2[target]
            if target in self_product2:
                res += v*self_product2[target]

        for k,v in c_nums2.items():
            target = k**2
            if target in cross_product1:
                res += v*cross_product1[target]
            if target in self_product1:
                res += v*self_product1[target]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def countTriplets(nums1,nums2):
            count = 0
            for index, val in enumerate(nums1):
                target = int(val**2)
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target % val2 == 0 and  (target // val2) in lookup:
                        count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

from collections import Counter
class Solution:
    def mul(self, x):
        ans = []
        n = len(x)
        for i in range(n-1):
            for j in range(i+1, n):
                ans.append(x[i] * x[j])
        return ans
    def count(self, x, y):
        ans = 0
        cx = Counter(x)
        cy = Counter(y)
        same = set(x).intersection(set(y))
        for num in same:
            # print(num, cx, cy)
            ans += cx[num] * cy[num]
        return ans
            
    def numTriplets(self, a: List[int], b: List[int]) -> int:
        ans = 0
        asq = [i*i for i in a]
        bsq = [i*i for i in b]
        aa = self.mul(a)
        bb = self.mul(b)
        ans += self.count(asq, bb)
        ans += self.count(bsq, aa)
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def count(n1, n2):
            ret = 0
            for x in n1:
                seen = collections.defaultdict(int)
                for y in n2:
                    if x*x % y == 0:
                        ret += seen[x*x // y]
                    seen[y] += 1    
            return ret
        return count(nums1, nums2) + count(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def cal(arr1, arr2):
            tmp = 0
            for n1 in arr1:
                n1pow2 = n1 * n1
                h = collections.defaultdict(int)
                for idx, n2 in enumerate(arr2):
                    if n1pow2 / n2 in h:
                        tmp += h[n1pow2 // n2]
                    h[n2] += 1
            return tmp
                    
        
        return cal(nums1, nums2) + cal(nums2, nums1)
                    
                


from math import sqrt
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        numTwoHave = defaultdict(lambda: 0)
        numOneHave = defaultdict(lambda: 0)
        
        for j in range(len(nums2)):
            for k in range(j+1,len(nums2)):
                numTwoHave[sqrt(nums2[j]*nums2[k])] += 1
                
        for j in range(len(nums1)):
            for k in range(j+1,len(nums1)):
                numOneHave[sqrt(nums1[j]*nums1[k])] += 1
        
        #print(numOneHave)
        #print(numTwoHave)
        
        triplets = 0
        
        for num in nums1:
            if num in numTwoHave:
                triplets += numTwoHave[num]
        for num in nums2:
            if num in numOneHave:
                triplets += numOneHave[num]
            
        return triplets


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        for num in nums1:
            res += self.two_product(num ** 2, nums2)
        for num in nums2:
            res += self.two_product(num ** 2, nums1)
        return res
    
    def two_product(self, target, nums):
        dic, res = {}, 0
        for i, num in enumerate(nums):
            if target % num:
                continue
            remain = target // num
            res += dic.get(remain, 0)
            dic[num] = dic.get(num, 0) + 1
        return res


import itertools
def calCross(nums):
    res = []
    pairs = list(itertools.combinations(nums,2))
    for (i,j) in pairs:
        res.append(i*j)
    return res

def commonCnt(nums1,nums2):
    res = 0
    cross = set(nums1)&set(nums2)
    for e in cross:
        res += nums1.count(e)*nums2.count(e)
    return res                    

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        square1 = [e*e for e in nums1]
        square2 = [e*e for e in nums2]
        cross1 = calCross(nums1)
        cross2 = calCross(nums2)
        res = commonCnt(square1, cross2)
        res += commonCnt(square2, cross1)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def countTriplets(nums1,nums2):
            count = 0
            for index, val in enumerate(nums1):
                target = val**2
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target / val2 in lookup:
                            count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1 = defaultdict(int)

        def countTriplets(nums1,nums2):
            count = 0
            for index, val in enumerate(nums1):
                target = val**2
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target % val2 == 0:
                        if target // val2 in lookup:
                            count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(l1, l2):
            d = {}
            for c in l1:
                if c**2 in d:
                    d[c**2] += 1
                else:
                    d[c**2] = 1
            
            r = {}
            for c in l2:
                if c in r:
                    r[c] += 1
                else:
                    r[c] = 1
                    
            count = 0   
            for c in l2:
                for s in d:
                    res, c2 = s%c, s//c
                    if res == 0 and c2 in r:
                        if c2 != c:
                            count += r[c2] * d[s]
                        else:
                            count += (r[c2]-1) * d[s]
            return count//2
        
        return helper(nums1, nums2) + helper(nums2,nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        def cal(n, nums):
            nonlocal ans
            d = defaultdict(int)
            for num in nums:
                if n % num == 0:
                    ans += d[n/num]
                d[num] += 1
            
        for n in nums1:
            cal(n*n, nums2)
        for n in nums2:
            cal(n*n, nums1)
            
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        set1 = set(nums1)
        set2 = set(nums2)
        lookup1 = defaultdict(int)

        def ncr(n,r):
            from math import factorial
            return factorial(n)//factorial(r) //factorial(n-r)
        
        def countTriplets(nums1,nums2):
            lookup = defaultdict(int)
            count = 0
            for index, val in enumerate(nums1):
                target = val**2
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target % val2 == 0:
                        if target // val2 in lookup:
                            count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

#Similar to twoSum problem. 
#Let's consider how we can find if value a ** 2 exists as a product of any 
#   two elements in array [x, y, ..., z]
#We can store in a set the value of a ** 2 / x for all x in array when fully divisible
#If the next value in array exists in in set, then we found a match
#The time complexity for finding one given value is O(N)
from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        
        for num in nums1:
            res += self.twoProduct(num * num, nums2)
            
        for num in nums2:
            res += self.twoProduct(num * num, nums1)
        
        return  res
    
    def twoProduct(self, val, nums):
        prod, res = defaultdict(int), 0
        for num in nums:
            res += prod[num]
            
            q, r = divmod(val, num)
            if r == 0: 
                prod[q] += 1
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.num(nums1, nums2) + self.num(nums2, nums1)
        
    def num(self, nums1, nums2):
        possibleSquares = {}
        possibleProducts = {}
        for (idx, x) in enumerate(nums1):
            square = x * x 
            if square in possibleSquares:
                possibleSquares[square].append(idx)
            else:
                possibleSquares[square] = [idx]
        for x in range(len(nums2) - 1):
            for y in range(x+1, len(nums2)):
                product = nums2[x] * nums2[y]
                if product in possibleProducts:
                    possibleProducts[product].append((x, y))
                else:
                    possibleProducts[product] = [(x, y)]
        result = 0
        for s in possibleSquares:
            if s in possibleProducts:
                result += len(possibleSquares[s]) * len(possibleProducts[s])
        return result


class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        res = 0
        def count(n2, arr):
            res = 0
            c = defaultdict(int)
            for n in arr:
                if n2 % n == 0:
                    res += c[n2//n]
                c[n] += 1
            return res
        
        for i, n in enumerate(A):
            res += count(n * n, B)
        for i, n in enumerate(B):
            res += count(n * n, A)
        return res
        
        
#         A.sort()
#         B.sort()
#         n, m = len(A), len(B)
#         res = 0
        
#         def perm(same):
#             if same <= 2:
#                 return 1
#             return (same - 1) * same // 2
        
#         def loop_me(arr, t, m, target):
#             res = 0
#             l, r = 0, m - 1
#             while l < r:
#                 tmp = arr[l] * arr[r]
#                 if tmp > t:
#                     r -= 1
#                 elif tmp < t:
#                     l += 1
#                 else:
#                     same = 0
#                     for k in range(l, r + 1):
#                         if arr[k] == arr[r]:
#                             same += 1
#                             # print(k, r)
#                         else:
#                             break
#                     print(\"--\", target, same, perm(same))
#                     # print(same)
#                     res += perm(same) 
#                     break             
#             return res
            
#         for i in range(n):
#             t = A[i] * A[i]
#             res += loop_me(B, t, m, A[i])

#         for i in range(m):
#             t = B[i] * B[i]
#             res += loop_me(A, t, n, A[i])
        
#         return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        count=self.counttrip(nums1,nums2)
        
        count+=self.counttrip(nums2,nums1)
        return int(count)
        
    def counttrip(self,nums1,nums2):
        
        count =0
        for i in nums1:
            
            
            target=i*i
            dictn=defaultdict(int)
            for j,x in enumerate(nums2):
                rem = target/x
                if(rem in dictn):
                    count+=dictn[rem]
                dictn[x]+=1
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # nums1 = sorted(nums1)
        # nums2 = sorted(nums2)
        res = 0
        for n1 in nums1:
            n1 = n1**2
            visited = collections.defaultdict(int)
            for n2 in nums2:
                if n1 % n2 == 0 and visited[n1//n2] > 0:
                    res += visited[n1//n2]
                visited[n2] += 1
                
        for n2 in nums2:
            n2 = n2**2
            visited = collections.defaultdict(int)
            for n1 in nums1:
                if n2 % n1 == 0 and visited[n2//n1] > 0:
                    res += visited[n2//n1]
                visited[n1] += 1
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        count=self.counttrip(nums1,nums2)
        
        count+=self.counttrip(nums2,nums1)
        return int(count)
        
    def counttrip(self,nums1,nums2):
        
        count =0
        seen=defaultdict(int)
        for i in nums1:
            
            
            target=i*i
            # if(target in seen):
            #     count+=seen[target]
            #     continue
            localcount=0
            dictn=defaultdict(int)
            for j,x in enumerate(nums2):
                rem = target/x
                if(rem in dictn):
                    localcount+=dictn[rem]
                dictn[x]+=1
            seen[target]+=localcount
            count+=localcount
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        if len(nums1) == 1 and len(nums2) == 1:
            return 0
        else:
            ans = 0
            n1 = Counter(nums1)
            n2 = Counter(nums2)
            for i in range(len(nums1)-1):
                for j in range(i+1, len(nums1)):
                    t = (nums1[i] * nums1[j])**(1/2)

                    if t == int(t) and t in n2:
                        ans += n2[t]

            for i in range(len(nums2)-1):
                for j in range(i+1, len(nums2)):
                    t = (nums2[i] * nums2[j])**(1/2)

                    if t == int(t) and t in n1:
                        ans += n1[t]
            return ans
                        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1,nums2):
            s1=Counter(nums1)
            s2=Counter(nums2)
            cnt=0
            for i in range(len(nums1)):
                need=nums1[i]*nums1[i]
                if need==0:
                    if 0 in s2:
                        cnt+=s2[0]*(len(num2)-1)-(s2[0]-1)*(s2[0]-1)
                    else:
                        cnt+=0
                else:
                    for j in range(len(nums2)):
                        kk=need/nums2[j]
                        if kk in s2:
                            if nums2[j]!=kk:
                                cnt+=s2[kk]/2
                            else:
                                cnt+=(s2[kk]-1)/2
                                
                                
                
            return int(cnt)
        return helper(nums1,nums2)+helper(nums2,nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1, nums2):
            ret = 0
            C = collections.Counter(nums2)
            s = sorted(C)
            for n in nums1:
                ret += C[n] * (C[n] - 1) // 2
                nn = n * n
                for d in s:
                    if d >= n:
                        break
                    if nn % d == 0:
                        ret += C[d] * C[nn // d]
            return ret
        
        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def tow_product(A, target):
            
            d = {}
            res = 0
            for x in A:
                if target%x==0 and target // x in d:
                    res += d[target//x]
                d[x] = d.get(x,0) + 1
            return res
        
        def count(nums1, nums2):
            res = 0
            last_cnt = 0
            for i in range(len(nums1)):
                if i>0 and nums1[i]==nums1[i-1]:
                    res+=last_cnt
                else:
                    last_cnt = tow_product(nums2, nums1[i]**2)
                    res += last_cnt
            return res
        
        nums1 = sorted(nums1)
        nums2 = sorted(nums2)
        return count(nums1, nums2) + count(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        m = len(nums2)
        
        res = 0
        for x in nums1 :
            t = x * x
            m = {}
            for y in nums2 :
                if t % y == 0 :
                    res += m.get(t//y, 0)
                m[y] = m.get(y, 0) + 1
        
        for y in nums2 :
            t = y * y
            m = {}
            for x in nums1 :
                if t % x == 0 :
                    res += m.get(t//x, 0)
                m[x] = m.get(x, 0) + 1
        
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        set1 = set(nums1)
        set2 = set(nums2)
        lookup1 = defaultdict(int)

        def countTriplets(nums1,nums2):
            lookup = defaultdict(int)
            count = 0
            for index, val in enumerate(nums1):
                target = val**2
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target % val2 == 0:
                        if target // val2 in lookup:
                            count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        muti_set1 = set()
        muti_set2 = set()
        muti_dict1 = dict()
        muti_dict2 = dict()
        
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                v = nums1[i] * nums1[j]
                if v in muti_set1:
                    muti_dict1[str(v)] = muti_dict1[str(v)] + 1
                else:
                    muti_dict1[str(v)] = 1
                    muti_set1.add(v)
            
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                v = nums2[i] * nums2[j]
                if v in muti_set2:
                    muti_dict2[str(v)] = muti_dict2[str(v)] + 1
                else:
                    muti_dict2[str(v)] = 1
                    muti_set2.add(v)
        
        res = 0
        print(muti_set1)
        print(muti_set2)
        
        for _ in nums1:
            if _*_ in muti_set2:
                res = res + muti_dict2[str(_*_)]
        
        for _ in nums2:
            if _*_ in muti_set1:
                res = res + muti_dict1[str(_*_)]
        
        return res


from collections import defaultdict as dt
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        cnt = 0
        for x in nums1:
            d = dt(int)
            for y in nums2:
                if (x * x) % y == 0 and (x*x)//y in d:
                    cnt += d[(x*x)//y]
                d[y] += 1
        
        for x in nums2:
            d = dt(int)
            for y in nums1:
                if (x * x) % y == 0 and (x*x)//y in d:
                    cnt += d[(x*x)//y]
                d[y] += 1
        return cnt

# Two sum approach

# returns the number of distinct index pairs (j, k) such that 
# array[j]*array[k] == target

from collections import defaultdict

# O(n) time, O(n) space
def two_product(array, target):
    counter = defaultdict(int)
    count = 0
    
    for index, value in enumerate(array):
        candidate = target / value
        if candidate in counter:
            count += counter[candidate]
        counter[value] += 1
        # print(f\"Counter: {counter}, count: {count}\")
    # print(counter)
    return count
    

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        for num in nums1:
            count += two_product(nums2, num*num)
        
        for num in nums2:
            count += two_product(nums1, num*num)
        
        return count

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        
        def helper(nums1, nums2):
            ans = 0
            for num1 in nums1:
                exist = defaultdict(int)
                v = num1 * num1
                for num2 in nums2:
                    if v % num2 == 0 and v / num2 in exist:
                        ans += exist[v / num2]
                    exist[num2] += 1
                    
            return ans
        return helper(nums1, nums2) + helper(nums2, nums1)
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        import collections
        h1 = {}
        s1 = collections.Counter()
        h2 = {}
        s2 = collections.Counter()
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                s1[nums1[i]*nums1[j]] += 1
                h1[(i, j)] = nums1[i]*nums1[j]
                
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                s2[nums2[i]*nums2[j]] += 1
                h2[(i, j)] = nums2[i]*nums2[j]
        ans = 0
        for i in range(len(nums1)):
            if nums1[i]*nums1[i] in s2:
                ans += s2[nums1[i]*nums1[i]]
                
        for i in range(len(nums2)):
            if nums2[i]*nums2[i] in s1:
                ans += s1[nums2[i]*nums2[i]]

        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def cntProduct(square: int, nums: List[int]) -> int:
            num_count, cnt = {}, 0
            for num in nums:
                if square % num == 0:
                    cnt += num_count.get(square // num, 0)
                num_count[num] = 1 + num_count.get(num, 0)     
            return cnt            
        
        return sum(cntProduct(num ** 2, nums2) for num in nums1) + sum(cntProduct(num ** 2, nums1) for num in nums2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        def cnt(tot, arr):
            mp = {}
            ans = 0
            for val in arr:
                if tot % val == 0 and tot / val in mp:
                    ans += mp[tot/val]
                mp[val] = mp.get(val, 0) + 1
            return ans
        
        def helper(arr1, arr2):
            last_num = None
            last_ans = None
            ans = 0
            for num in arr1:
                if num == last_num:
                    ans += last_ans
                else:
                    last_num = num
                    last_ans = cnt(num * num, arr2)
                    ans += last_ans
            return ans
        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def find(self, nums, target):
        seen = collections.defaultdict(int)
        res = 0
        for i in nums:
            if target % i == 0 and target/i in seen:
                res += seen[target/i]
            seen[i] += 1
        return res
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        for i in nums1:
            target = i * i
            res += self.find(nums2, target)
        for i in nums2:
            target = i * i
            res += self.find(nums1, target)
        return res

# Two sum approach

# returns the number of distinct index pairs (j, k) such that 
# array[j]*array[k] == target

from collections import defaultdict

# O(n) time, O(n) space
def two_product(array, target):
    counter = defaultdict(int)
    count = 0
    
    for index, value in enumerate(array):
        candidate = target / value
        if candidate in counter:
            count += counter[candidate]
        counter[value] += 1
    return count
    

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        for num in nums1:
            count += two_product(nums2, num*num)
        
        for num in nums2:
            count += two_product(nums1, num*num)
        
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def helper(nums1, nums2):
            # n1 = len(num1)
            # n2 = len(num2)
            res = 0
            for num in nums1:
                val = num ** 2
                dic = collections.defaultdict(int)
                for e in nums2:
                    # if e in dic:
                    res += dic[e]
                    dic[val/e] += 1
            return res
        return helper(nums1, nums2) + helper(nums2, nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        num12 = [x*x for x in nums1]
        num22 = [x*x for x in nums2]
        
        ans=0
        #print(num12,num22)
        
        for j2 in num22:
            c2 = Counter() #num2**2 / num1
            for i in nums1:
                if j2%i==0:
                    ans += c2[i]
                    c2[j2//i]+=1
        for j1 in num12:
            c1 = Counter() #num1**2 / num2
            for i in nums2:
                if j1%i==0:
                    ans += c1[i]
                    c1[j1//i]+=1
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        n1 = len(nums1)
        n2 = len(nums2)
        res = 0
        
        for i in range(n1):
            x = nums1[i]**2    
            mp = defaultdict(int)
            for j in range(n2):
                if x%nums2[j]==0:
                    y = x//nums2[j]
                    if y in mp:
                        res += mp[y]
                mp[nums2[j]]+=1
                
        for i in range(n2):
            x = nums2[i]**2    
            mp = defaultdict(int)
            for j in range(n1):
                if x%nums1[j]==0:
                    y = x//nums1[j]
                    if y in mp:
                        res += mp[y]
                mp[nums1[j]]+=1
         
        return res
            
        


from collections import Counter
from math import sqrt
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def is_perfect(x):
            return int(sqrt(x))**2 == x
        size1, size2 = len(nums1), len(nums2)
        count1, count2 = Counter(nums1), Counter(nums2)
        max1, max2 = max(nums1), max(nums2)
        nums1.sort()
        nums2.sort()
        res = 0
        for i in range(size2):
            if nums2[i] > max1:
                break
            for j in range(i+1, size2):
                mul = nums2[i]*nums2[j]
                if is_perfect(mul):
                    res += count1[int(sqrt(mul))]
        for i in range(size1):
            if nums1[i] > max2:
                break
            for j in range(i+1, size1):
                mul = nums1[i]*nums1[j]
                if is_perfect(mul):
                    res += count2[int(sqrt(mul))]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        d1 = collections.defaultdict(int)
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                sqr = math.sqrt(nums1[i]*nums1[j])
                if sqr == int(sqr):
                    d1[int(sqr)] += 1
        for i in nums2:
            if i in d1:
                res += d1[i]
                
        d2 = collections.defaultdict(int)
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                sqr = math.sqrt(nums2[i]*nums2[j])
                if sqr == int(sqr):
                    d2[int(sqr)] += 1
        for i in nums1:
            if i in d2:
                res += d2[i]
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        prod1={}
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                if nums1[i]*nums1[j] not in prod1.keys():
                    prod1[nums1[i]*nums1[j]] = 1
                else:
                    prod1[nums1[i]*nums1[j]] += 1
        prod2={}
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                if nums2[i]*nums2[j] not in prod2.keys():
                    prod2[nums2[i]*nums2[j]] = 1
                else:
                    prod2[nums2[i]*nums2[j]] += 1
        
        cnt = 0
        for i in nums1:
            if i*i in prod2.keys():
                cnt+=prod2[i*i]
                
        for i in nums2:
            if i*i in prod1.keys():
                cnt+=prod1[i*i]
    
        

        return cnt

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        dic1 = {}
        dic2 = {}
        for x in nums1:
            if x not in dic1:dic1[x] = 0
            dic1[x] += 1
        for x in nums2:
            if x not in dic2:dic2[x] = 0
            dic2[x] += 1
        
        for k,v in dic1.items():
            for k1,v1 in dic2.items():
                if k1 < k:
                    if k**2 % k1 == 0:
                        if k**2/k1 in dic2:
                            result += v*v1*dic2[k**2/k1]
                elif k1 == k:
                    result += v * v1 * (v1-1) /2
        
        for k,v in dic2.items():
            for k1,v1 in dic1.items():
                if k1 < k:
                    if k**2 % k1 == 0:
                        if k**2/k1 in dic1:
                            result += v*v1*dic1[k**2/k1]
                elif k1 == k:
                    result += v * v1 * (v1-1) /2      
                
        return int(result)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def count(nums1, nums2):
            # triplets = set()
            triplets = 0

            cnt2 = {}
            for i2, num2 in enumerate(nums2):
                if num2 not in cnt2:
                    cnt2[num2] = []
                cnt2[num2].append(i2)        

            for i1, num1 in enumerate(nums1):
                # print('stage1', i1, num1)
                square = num1 ** 2

                for num2j, idxs2j in cnt2.items():
                    if square % num2j != 0:
                        continue

                    num2k = int(square // num2j)

                    if num2k not in cnt2:
                        continue

                    idxs2k = cnt2[num2k]
                    
                    combined = []
                    for idx2j in idxs2j:
                        combined.append((idx2j, 0))  # j
                    for idx2k in idxs2k:
                        combined.append((idx2k, 1))
                    combined.sort()
                    temp_cnt = 0
                    for comb in combined:
                        idx, ty = comb
                        if ty == 0:
                            triplets += temp_cnt
                        else:
                            temp_cnt += 1
                    
                    
#                     print(num1, square, idxs2j, idxs2k, j, k)
#                     while j >= 0:
#                         print(j, k, larger)
#                         if idxs2j[j] < idxs2k[k]:
#                             if k > 0:
#                                 larger += 1
#                                 k -= 1
#                             else:
#                                 if larger == 0:
#                                     larger = 1
#                                 triplets += larger
#                                 j -= 1
#                             # if k < 0:
#                             #     triplets += larger
#                             #     break
#                         else:
#                             triplets += larger
#                             j -= 1
#                     # triplets += larger
                    
#                     print('triplets=', triplets)
                    
                    
                    # print('stage2', idxs2k)
                    
                    # for idx2j in idxs2j:
                    #     for idx2k in idxs2k:
                    #         if idx2k <= idx2j:
                    #             continue
                    #         triplets += 1
                            # triplets.add((i1, idx2j, idx2k))
                            # print(num1, nums2[idx2j], nums2[idx2k])

            return triplets
            
        
        triplets1 = count(nums1, nums2)
        triplets2 = count(nums2, nums1)
                
        # return len(triplets1) + len(triplets2)
        return triplets1 + triplets2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def comb(nums, k):
            res = 0
            count = collections.defaultdict(int)
            for i in range(len(nums)):
                x = nums[i]
                y = k * k // x
                if x * y == k * k:
                    res += count[y]
                count[x] += 1
            return res

        res = 0
        for x in nums1:
            res += comb(nums2, x)
        for x in nums2:
            res += comb(nums1, x)
        return res

class Solution:
    def formMulitplication(s, a):
        # a should have been sorted in ascending order 
        n=len(a)
        square_nums=[]
        for i in range(n-1):
            for j in range(i+1, n):
                p=a[i]*a[j]
                sqrt_p=int(sqrt(p))
                if sqrt_p*sqrt_p==p:
                    square_nums.append(sqrt_p)
        return square_nums
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        
        countnums1=[0 for i in range(100000+1)]
        countnums2=[0 for i in range(100000+1)]
        
        for i in range(len(nums1)):
            countnums1[nums1[i]]+=1
        for i in range(len(nums2)):
            countnums2[nums2[i]]+=1
        
        square_nums1=self.formMulitplication(nums1)
        result_type1=0
        for i in range(len(square_nums1)):
            result_type1+=countnums2[square_nums1[i]]
        
        square_nums2=self.formMulitplication(nums2)
        result_type2=0
        for i in range(len(square_nums2)):
            result_type2+=countnums1[square_nums2[i]]
        
        return (result_type1+result_type2)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = defaultdict(list)
        d2 = defaultdict(list)
        
        for i, x in enumerate(nums1):
            for j, y in enumerate(nums1):
                if j <= i:
                    continue
                r = int(sqrt(x * y))
                if  r**2 == x * y:
                    d1[r].append((i , j))
                    
        for i, x in enumerate(nums2):
            for j, y in enumerate(nums2):
                if j <= i:
                    continue
                r = int(sqrt(x * y))
                if r**2 == x * y:
                    d2[r].append((i , j))
        ret = 0        
        for i in nums1:
            ret += len(d2[i])
        for i in nums2:
            ret += len(d1[i])
        
        return ret

class Solution:
    # O(n²)
    # def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
    #     m , n = len(nums1),len(nums2)
    #     def fillUpper(m,nums):
    #         mapp1 = defaultdict(int)
    #         for i in range(m-1):
    #             for j in range(i+1,m):
    #                 mapp1[nums[i]*nums[j]]+=1
    #         return  mapp1
    #     mat1 = fillUpper(m,nums1)
    #     mat2 = fillUpper(n,nums2)
    #     res = 0
    #     for i in nums1:
    #         c=i**2 
    #         if(c in mat2):
    #             res+=mat2[c]
    #     for i in nums2:
    #         c= i**2 
    #         if(c in mat1):
    #             res+=mat1[c]       
    #     return res
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def count(nums1,nums2):
            res = 0
            for i in nums1:
                map1 = defaultdict(int)
                sq = i**2
                for j in nums2:
                    comp = sq/j
                    if(j in map1):
                        res+=map1[j]
                    map1[comp]+=1
            return res
        return count(nums1,nums2)+count(nums2,nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        set1 = collections.defaultdict(set)
        for i, num in enumerate(nums1):
            set1[num].add(i)
        set2 = collections.defaultdict(set)
        for i, num in enumerate(nums2):
            set2[num].add(i)
        
        res = 0
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                if (nums2[i] * nums2[j]) ** 0.5 == int((nums2[i] * nums2[j]) ** 0.5):
                    m = int((nums2[i] * nums2[j]) ** 0.5)
                    if m in set1:
                        # print(m, i, j)
                        res += len(set1[m])
        
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                if (nums1[i] * nums1[j]) ** 0.5 == int((nums1[i] * nums1[j]) ** 0.5):
                    m = int((nums1[i] * nums1[j]) ** 0.5)
                    if m in set2:
                        # print(m, i, j)
                        res += len(set2[m])
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        num12 = [x*x for x in nums1]
        num22 = [x*x for x in nums2]
        
        ans=0
        #print(num12,num22)
        for j2 in num22:
            c2 = Counter() #num2**2 / num1
            for i in nums1:
                if j2%i==0:
                    if i in c2:
                        ans += c2[i]
                    c2[j2//i]+=1
        for j1 in num12:
            c1 = Counter() #num1**2 / num2
            for i in nums2:
                if j1%i==0:
                    if i in c1:
                        ans += c1[i]
                    c1[j1//i]+=1
        return ans

from collections import defaultdict

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
#         nums1[i] ^ 2 = nums2[j] * nums2[k]
#          

        def solv(A, B):
            ans = 0
            for a in A:
                x = a**2 
                seen = defaultdict(lambda: 0)
                for b in B:
                    q, r = divmod(x, b)
                    if r != 0:
                        seen[b] += 1
                        continue
                    ans += seen[q]              
                    seen[b] += 1
            return ans
        
        return solv(nums1, nums2) + solv(nums2, nums1)


from itertools import combinations

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def isPerSq(n):
            return int(math.sqrt(n) + 0.5) ** 2 == n
        
        d1 = Counter(nums1)
        d2 = Counter(nums2)
        
        s = 0
        for x,y in combinations(nums2, 2):
            if isPerSq(x*y):
                s += d1[math.sqrt(x*y)]
        
        for x,y in combinations(nums1, 2):
            if isPerSq(x*y):
                s += d2[math.sqrt(x*y)]
        
        return s

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def generate_nums(nums):
            nums = sorted(list(collections.Counter(nums).items()))
            n = len(nums)
            pow_nums = defaultdict(int)
            mul_nums = defaultdict(int)
            for i in range(n):
                num = nums[i][0]
                pow_nums[num * num] += nums[i][1]
                for j in range(i + 1, n):
                    mul_nums[num * nums[j][0]] += nums[i][1] * nums[j][1]

                mul_nums[num * num] += nums[i][1] * (nums[i][1] - 1) // 2
                
            return (pow_nums, mul_nums)
        
        (pow_nums1, mul_nums1) = generate_nums(nums1)
        (pow_nums2, mul_nums2) = generate_nums(nums2)
        
        ans = 0
        
        def check_triplet(nums, pow_nums):
            ans = 0
            for num, count in nums.items():
                ans += pow_nums[num] * count
            return ans
                        
        ans += check_triplet(mul_nums1, pow_nums2)
        ans += check_triplet(mul_nums2, pow_nums1)
        
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        p1={}
        p2={}
        c=0
        for i in range(len(nums1)):
            for j in range(len(nums1)):
                if i!=j:
                    p1[nums1[i]*nums1[j]]=p1.get(nums1[i]*nums1[j],0)+1
             
        for i in range(len(nums2)):
            for j in range(len(nums2)):
                if i!=j:
                    p2[nums2[i]*nums2[j]]=p2.get(nums2[i]*nums2[j],0)+1
             
        for i in nums1:
            if i*i in list(p2.keys()):
                c+=p2[i*i]//2
        for i in nums2:
            if i*i in list(p1.keys()):
                c+=p1[i*i]//2
        return c
            
                
       
                


import itertools, math
from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def is_perfect_square(n):
            return int(math.sqrt(n) + 0.5) ** 2 == n
        
        nums1_cntr, nums2_cntr = Counter(nums1), Counter(nums2)
        
        s = 0
        for x, y in itertools.combinations(nums2, 2):
            if is_perfect_square(x * y):
                s += nums1_cntr[math.sqrt(x * y)]
                
        for x, y in itertools.combinations(nums1, 2):
            if is_perfect_square(x * y):
                s += nums2_cntr[math.sqrt(x * y)]
                
        return s
    
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        
        
        for n in nums1:
            n2 = n*n
            seen = collections.defaultdict(int)
            for i in range(len(nums2)):
                ans += seen[n2/nums2[i]]
                seen[nums2[i]] += 1
            
        
        
        for n in nums2:
            n2 = n*n
            seen = collections.defaultdict(int)
            for i in range(len(nums1)):
                ans += seen[n2/nums1[i]]
                seen[nums1[i]] += 1
        
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans=0 
        nums1square=[]
        for i in nums1:
            nums1square.append(i*i)
          
        for i in nums1square:
            d=dict()
            for j in nums2:
                if(i%j==0):
                    if(i/j in d.keys()):
                        ans+=d[i/j]
                    if(j in d.keys()):
                        d[j]+=1
                    else:
                        d[j]=1
        nums2square=[]
        for i in nums2:
            nums2square.append(i*i)
          
        for i in nums2square:
            d=dict()
            for j in nums1:
                if(i%j==0):
                    if(i/j in d.keys()):
                        ans+=d[i/j]
                    if(j in d.keys()):
                        d[j]+=1
                    else:
                        d[j]=1
        
                
            
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        res = 0
        if len(nums1) == 1 and len(nums2) == 1:
            return 0
        
        
        if set(nums1) == set(nums2) and len(set(nums1)) == 1:
            res =  len(nums2) * (len(nums2) - 1) // 2 
            res = res * len(nums1)
            res = res + (len(nums1) * (len(nums1) - 1) // 2) * len(nums2)
            return res
        
        m1 = self.getmultiply(nums1)
        m2 = self.getmultiply(nums2)
        
        for x in nums1:
            if x * x in m2:
                res = res + len(m2[x*x])
        for y in nums2:
            if y * y in m1:
                res = res + len(m1[y*y])
        

                                
        return res

        
    def getmultiply(self,nums):
        
        res = {}
        
        for x in range(len(nums)):
            for y in range(x+1,len(nums)):
                if nums[x] * nums[y] in res and [x,y]:
                    res[nums[x]*nums[y]].append([x,y])
                else:
                    res[nums[x]*nums[y]] = [[x,y]]
        return res
 



    def getsq(self,nums):
        
        res = {}
        
        for x in range(len(nums)):
            if nums[x] * nums[x] in res :
                if x not in res[nums[x] * nums[x]]:
                    res[nums[x] * nums[x]].append(x)
            else:
                res[nums[x] * nums[x]] = [x]
                
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # tow product. O(nm), O(n)
        cnt = 0
        for num in nums1:
            target = num * num
            cnt += self.twoProduct(nums2, target)
        
        for num2 in nums2:
            target2 = num2 * num2
            cnt += self.twoProduct(nums1, target2)
        
        return cnt
    
    def twoProduct(self, nums, target):
        cnt = 0
        hashmap = collections.defaultdict(int)
        for i in range(len(nums)):
            if target / nums[i] in hashmap:
                cnt += hashmap[target / nums[i]]
            hashmap[nums[i]] += 1
            
        return cnt


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1={}
        d2={}
        for i in nums1:
            d1[i]=d1.get(i,0)+1
        for i in nums2:
            d2[i]=d2.get(i,0)+1
        ans=0
        d3={}
        print(d1,d2)
        for i in range(len(nums1)):
            d3={}
            for j in range(len(nums2)):
                if (nums1[i]*nums1[i])%nums2[j]==0:
                    #print(1,nums1[i],nums2[j])
                    x=(nums1[i]*nums1[i])//nums2[j]
                    y=nums2[j]
                    if d3.get((x,y),-1)==-1:
                        if x==y:
                            x1=d2.get(x,0)
                            ans+=(x1*(x1-1))//2
                            d3[(x,y)]=1
                        else:    
                        #print(1,d2,(nums1[i]*nums1[i])//nums2[j])
                            ans+=d2.get(x,0)*d2.get(y,0) 
                            #d2[nums2[j]]+=1
                            d3[(x,y)]=1
                            d3[(y,x)]=1
        d4={}
        for i in range(len(nums2)):
            d4={}
            for j in range(len(nums1)):
                if (nums2[i]*nums2[i])%nums1[j]==0:
                    #d1[nums1[j]]-=1
                    x=((nums2[i]*nums2[i])//nums1[j])
                    y=nums1[j]
                    if d4.get((x,y),-1)==-1:
                        #print(2,nums2[i],nums1[j])
                        #print(2,d1,((nums2[i]*nums2[i])//nums1[j]))
                        if x==y:
                            x1=d1.get(x,0)
                            ans+=(x1*(x1-1))//2
                            d4[(x,y)]=1
                        else:    
                            ans+=d1.get(x,0)*d1.get(y,0) 
                            #d1[nums1[j]]+=1
                            d4[(x,y)]=1
                            d4[(y,x)]=1
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def cnt(tot, arr):
            mp = {}
            ans = 0
            for val in arr:
                if tot % val == 0 and tot / val in mp:
                    ans += mp[tot/val]
                mp[val] = mp.get(val, 0) + 1
            return ans
        ans = 0
        for num in nums1:
            ans += cnt(num * num, nums2)
        for num in nums2:
            ans += cnt(num * num, nums1)
        return ans

class Solution:
    def numTriplets(self, nums1, nums2):
        mp1, mp2 = {}, {}
        for ele in nums1:
            if ele in mp1: mp1[ele] += 1
            else: mp1[ele] = 1
        for ele in nums2:
            if ele in mp2: mp2[ele] += 1
            else: mp2[ele] = 1
        
        ans = 0
        for k1, v1 in mp1.items():
            tar = k1 ** 2
            for k2 in sorted(mp2.keys()):
                if k2 ** 2 > tar: break
                elif k2 ** 2 == tar:
                    ans += v1 * mp2[k2] * (mp2[k2] - 1) // 2
                elif tar % k2 == 0 and (tar // k2) in mp2:
                    ans += v1 * mp2[k2] * mp2[tar // k2]
        for k2, v2 in mp2.items():
            tar = k2 ** 2
            for k1 in sorted(mp1.keys()):
                if k1 ** 2 > tar: break
                elif k1 ** 2 == tar:
                    ans += v2 * mp1[k1] * (mp1[k1] - 1) // 2
                elif tar % k1 == 0 and (tar // k1) in mp1:
                    ans += v2 * mp1[k1] * mp1[tar // k1]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        for num in nums1:
            ans += self.find_num_pairs(num, nums2)
        
        for num in nums2:
            ans += self.find_num_pairs(num, nums1)
        return ans
    
    def find_num_pairs(self, num, pair_list):
        pair_dict = {}
        square_num = num ** 2
        ans = 0
        for i, n in enumerate(pair_list):
            if square_num // n in pair_dict and square_num % n == 0:
                ans += len(pair_dict[square_num // n])
                # print(pair_dict[square_num // n], i, square_num // n, n, num)
            if n not in pair_dict:
                pair_dict[n] = []
            pair_dict[n].append(i)
        
        return ans
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        s1 = collections.Counter()
        for n1 in nums1:
            s2 = collections.Counter()
            for n2 in nums2:
                if n1 * n1 % n2 == 0 and n1 * n1 // n2 in s2:
                    res += s2[n1 * n1 // n2]
                if n2 * n2 % n1 == 0 and n2 * n2 // n1 in s1:
                    res += s1[n2 * n2 // n1]
                s2[n2] += 1
            s1[n1] += 1
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        for ele in nums1:
            res += self.twoProduct(ele*ele, nums2)

        for ele in nums2:
            res += self.twoProduct(ele*ele, nums1)
        
        return res
        
        
    def twoProduct(self, prod, nums):
        d = {}
        n = len(nums)
        res = 0
        for i in range(n):
            if prod%nums[i]==0 and prod//nums[i] in d:
                res += d[prod//nums[i]]
            if nums[i] in d:
                d[nums[i]] += 1
            else:
                d[nums[i]] = 1
                
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1 = sorted(nums1)
        nums2 = sorted(nums2)
        count = 0
        for item in nums1:
            count += self.get_equal_square(item*item, nums2)
        for item in nums2:
            count += self.get_equal_square(item*item, nums1)
        return count
    
    def get_equal_square(self, val, arr):
        count = 0
        m = {}
        for i, item in enumerate(arr):
            # if val == 16:
            #     print(i, item, m, arr)
            if val % item:
                continue
            tmp = val / item
            if m.get(tmp, None):
                count +=  m.get(tmp)
            m[item] = m.get(item, 0) + 1
        return count
        
        


from collections import Counter
import math
class Solution:
    def f(self,nums1, nums2):
        n1 = len(nums1)
        freq_dict_2 = Counter(nums2)
        answer = 0
        for pos_a,a in enumerate(nums1):
            for pos_b in range(pos_a+1,n1):
                b = nums1[pos_b]
                c_square = a*b
                potential_c = math.floor(math.sqrt(c_square))
                #print(f\"{potential_c}**2 = {c_square}\")
                #print(f\"{a}{b}{potential_c}\")
                if potential_c**2 == (c_square):
                    if potential_c in freq_dict_2:
                        answer += freq_dict_2[potential_c]
        return answer
                    
                    
            
        
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        final_answer = 0
        final_answer += self.f(nums1,nums2)
        final_answer += self.f(nums2,nums1)
        return final_answer
        
       


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def c(nums1, nums2):
            ans = 0
            for num in nums1:
                count = defaultdict(int)

                for i in range(len(nums2)):
                    if nums2[i] in count:
                        ans += count[nums2[i]]

                    new = num*num
                    if new % nums2[i] == 0:
                        count[new//nums2[i]] += 1

            return ans

        ans = c(nums1, nums2) + c(nums2, nums1)
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        for i in range(len(nums1)):
            h1 = {}
            target = nums1[i] * nums1[i]
            for j in range(len(nums2)):
                if target/nums2[j] in h1:
                    ans += h1[target/nums2[j]]
                if nums2[j] in h1:
                    h1[nums2[j]] += 1
                else:
                    h1[nums2[j]] = 1
                
        for i in range(len(nums2)):
            h2 = {}
            target = nums2[i] * nums2[i]
            for j in range(len(nums1)):
                if target/nums1[j] in h2:
                    ans += h2[target/nums1[j]]
                if nums1[j] in h2:
                    h2[nums1[j]] += 1
                else:
                    h2[nums1[j]] = 1        

        return ans
    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        for num1 in nums1:
            a = num1 * num1
            hashSet = defaultdict(int)
            for num2 in nums2:
                complement = a / num2
                if complement in hashSet:
                    count += hashSet[complement]
                hashSet[num2] += 1
        for num2 in nums2:
            a = num2 * num2
            hashSet = defaultdict(int)
            for num1 in nums1:
                complement = a / num1
                if complement in hashSet:
                    count += hashSet[complement]
                hashSet[num1] += 1
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.calc(nums1, nums2) + self.calc(nums2, nums1)

    def calc(self, nums1, nums2):
        d, ans = defaultdict(int), 0
        for num in nums2:
            d[num] += 1
        for i, num1 in enumerate(nums1):
            visited = {num: False for num in d}
            for num2 in d:
                cnt2 = d[num2]
                if visited[num2]:
                    continue
                if num1 * num1 % num2 == 0 and num1 * num1 // num2 in d:
                    num3, cnt3 = num1 * num1 // num2, d[num1 * num1 // num2]
                    ans += cnt2 * cnt3 if num2 != num3 else cnt2 * (cnt2 - 1) // 2
                    visited[num3] = True
                    visited[num2] = True
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def twoProduct(list1, list2, target):
            res = 0
            counter = collections.defaultdict(int)
            for j in range(len(list2)):
                q, r = divmod(target, list2[j])
                if r == 0 and q in counter:
                    res += counter[q]
                counter[list2[j]] += 1
            return res
        
        res = 0
        for n in nums1:
            res += twoProduct(nums1, nums2, n ** 2)
        for n in nums2:
            res += twoProduct(nums2, nums1, n ** 2)
        return res

import sys
input = sys.stdin.readline
from collections import *

class Solution:
    def calc(self, l1, l2):
        cnt = Counter(l2)
        res = 0
        
        for i in range(len(l1)):
            for j in range(len(l2)):
                if l1[i]*l1[i]%l2[j]==0:
                    k = l1[i]*l1[i]//l2[j]
                    res += cnt[k]
                    
                    if l2[j]==k:
                        res -= 1
        
        return res//2
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.calc(nums1, nums2)+self.calc(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        ans = 0
        for i in range(len(nums1)):
            h1 = {}
            target = nums1[i] * nums1[i]
            for j in range(len(nums2)):
                if target/nums2[j] in h1:
                    ans += h1[target/nums2[j]]
                if nums2[j] in h1:
                    h1[nums2[j]] += 1
                else:
                    h1[nums2[j]] = 1
                
                
        for i in range(len(nums2)):
            h2 = {}
            target = nums2[i] * nums2[i]
            for j in range(len(nums1)):
                if target/nums1[j] in h2:
                    ans += h2[target/nums1[j]]
                if nums1[j] in h2:
                    h2[nums1[j]] += 1
                else:
                    h2[nums1[j]] = 1        

        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:  
        fin = 0
        
        for n in nums1:
            sq = n * n
            res = {}
            ans = defaultdict(list)
            
            for i, x in enumerate(nums2):
                y = sq/x
                
                if y in ans:
                    fin += len(ans[y])
                ans[x].append(i)
        
        
        for n in nums2:
            sq = n * n
            res = set()
            ans = defaultdict(list)
            
            for i, x in enumerate(nums1):
                y = sq/x
                
                if y in ans:
                    fin += len(ans[y])
                ans[x].append(i)

        return fin


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        #type1
        d1 = collections.defaultdict(int)
        l1 = [i**2 for i in nums1]
        for i in range(len(nums2)):
            if nums2[i] in d1:
                res += d1[nums2[i]]
            for j in range(len(l1)):
                if l1[j] % nums2[i] == 0:
                    d1[l1[j]//nums2[i]] += 1
        d2 = collections.defaultdict(int)
        l2 = [i**2 for i in nums2]
        for i in range(len(nums1)):
            if nums1[i] in d2:
                res += d2[nums1[i]]
            for j in range(len(l2)):
                if l2[j] % nums1[i] == 0:
                    d2[l2[j]//nums1[i]] += 1
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ind1, ind2 = defaultdict(list), defaultdict(list)
        
        for i, v in enumerate(nums1):
            ind1[v].append(i)
        for i, v in enumerate(nums2):
            ind2[v].append(i)
        
        type1, type2 = 0, 0
        
        for i, v in enumerate(nums1):
            for j, v2 in enumerate(nums2):
                if (v*v)%v2:
                    continue
                req = (v*v) // v2
                # print(i, j, ind2[req])
                type1 += len(ind2[req]) - (v2 == req)
        
        for i, v in enumerate(nums2):
            for v1 in nums1:
                if (v*v)%v1:
                    continue
                req = (v*v) // v1
                type2 += len(ind1[req]) - (v1 == req)
        print(type1, type2)
        ans = (type1//2) + (type2//2)
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        for x in nums1:
            seen = {}
            v = x*x
            for i in nums2:
                if i in seen:
                    count+=seen[i]
                seen[v/i] = seen.get(v/i,0)+1
        for x in nums2:
            seen = {}
            v = x*x
            for i in nums1:
                if i in seen:
                    count+=seen[i]
                seen[v/i] = seen.get(v/i,0)+1
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.check_list(nums1, nums2) + self.check_list(nums2, nums1)
        
    def check_list(self, nums1, nums2):
        count = 0
        for value in nums1:
            target = value ** 2
            count += self.find_two_sum(nums2, target)
            
        return count
            
            
    def find_two_sum(self, nums, target):
        found = dict()
        count = 0
        for idx, num in enumerate(nums):
            
            if target % num != 0:
                continue
            
            search_val = target // num
            
            if search_val in found.keys():
                count += len(found[search_val])
                
            if num in found.keys():
                found[num].append(idx)
                
            else:
                found[num] = [idx]
                
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1, nums2):
            target = [i**2 for i in nums1]
            ans = 0
            for i in range(len(target)): 
                s = target[i]
                d = collections.defaultdict(list)
                for j in range(len(nums2)):
                    if nums2[j] in d: ans += len(d[nums2[j]])
                    d[s/nums2[j]].append(j)
            #print(ans)            
            return ans
        return helper(nums1, nums2) + helper(nums2, nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        tmp_dict1 = dict()
        res = 0
        for i, v in enumerate(nums1):
            if v not in tmp_dict1:
                tmp_dict1[v] = self.get_num_tr(v, nums2)
            res += tmp_dict1.get(v)
            
        tmp_dict2 = dict()
        for i, v in enumerate(nums2):
            if v not in tmp_dict2:
                tmp_dict2[v] = self.get_num_tr(v, nums1)
            res += tmp_dict2.get(v)
        return res
                    
    def get_num_tr(self, num, nums):
        n = num * num
        res = 0
        dct = dict()
        for i, v in enumerate(nums):
            if (n % v == 0):
                res += dct.get(int(n/v), 0)
            dct[v] = dct.get(v, 0) + 1

        return res
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.triplets(nums1, nums2) + self.triplets(nums2, nums1)
    
    def triplets(self, nums1, nums2):
        nums1_sq = [x*x for x in nums1]
        n_triplets = 0
        for i in range(len(nums1_sq)):
            nums2_lookup = {}
            for j in range(len(nums2)):
                if nums1_sq[i] % nums2[j] != 0:
                    continue
                num_to_look_for = nums1_sq[i] / nums2[j]
                count = nums2_lookup.get(num_to_look_for, 0)
                n_triplets += count
                if nums2[j] in nums2_lookup:
                    nums2_lookup[nums2[j]] += 1
                else:
                    nums2_lookup[nums2[j]] = 1
                
        
        return n_triplets

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def get_prod_dic (arr, num_dic):
           # num_dic = {}
        
            i = 0
            while i < len(arr):
                j = i + 1
                while j < len(arr):
                    p = arr[i] * arr[j]
                    if p not in num_dic:
                        num_dic[p] = []
                    num_dic[p].append([i, j])
                    j += 1
                i += 1
                
            return
        
        n1_dic = {}
        get_prod_dic(nums1, n1_dic)
        
        n2_dic = {}
        get_prod_dic(nums2, n2_dic)
        
        count = 0
        for n in nums1:
            p = n * n
            if p in n2_dic:
                count += len(n2_dic[p])
        for n in nums2:
            p = n * n
            if p in n1_dic:
                count += len(n1_dic[p])
        
        return count
            
        
        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        dic1 = {}
        dic2 = {}
        for i, e in enumerate(nums1):
            target = e ** 2
            for j in range(len(nums2)):
                if target % nums2[j] == 0:
                    if nums2[j] in dic1:
                        res += dic1[nums2[j]]
                    dic1[target//nums2[j]]=dic1.get(target//nums2[j],0)+1
            dic1={}
        


        for i, e in enumerate(nums2):
            target = e ** 2
            for j in range(len(nums1)):
                if target % nums1[j] == 0:
                    if nums1[j] in dic2:
                        res += dic2[nums1[j]]
                    dic2[target // nums1[j]] = dic2.get(target // nums1[j], 0) + 1
            dic2={}

        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        from collections import Counter
        c1 = Counter(nums1)
        c2 = Counter(nums2)
        
        ans = 0
        for j in range(len(nums2)):
            for k in range(j+1, len(nums2)):
                if math.sqrt(nums2[j]*nums2[k]) in c1:
                    ans += c1[math.sqrt(nums2[j]*nums2[k])]
        
        for j in range(len(nums1)):
            for k in range(j+1, len(nums1)):
                if math.sqrt(nums1[j]*nums1[k]) in c2:
                    ans += c2[math.sqrt(nums1[j]*nums1[k])]
        
        return ans
    
                
            


from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1, c2 = Counter(nums1), Counter(nums2)
        n, m = len(nums1), len(nums2)
        ans = 0
        for i in range (n):
            for j in range (m):
                nums2_k = (nums1[i] * nums1[i]) / nums2[j]
                ans += c2[nums2_k]
                if nums2_k == nums2[j]:
                    ans -= 1
            
        for i in range (m):
            for j in range (n):
                nums1_k = (nums2[i] * nums2[i]) / nums1[j]
                ans += c1[nums1_k]
                if nums1_k == nums1[j]:
                    ans -= 1
        
        return ans//2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        D = {}
        G = {}
        H = {}
        N1 = {}
        N2 = {}
        
        for i in range(len(nums1)):
            N1[nums1[i]] = 1
            for j in range(i+1, len(nums1)):
                D[nums1[i] * nums1[j]] = 1
                
        for i in range(len(nums2)):
            N2[nums2[i]] = 1
            for j in range(i+1, len(nums2)):
                G[nums2[i] * nums2[j]] = 1
                
        for i in range(len(nums1)):
            if nums1[i]**2 in G:
                if nums1[i]**2 not in H:
                    tmp = 0
                    for x in range(len(nums2)):
                        if nums1[i]**2 % nums2[x]==0 and (nums1[i]**2)//nums2[x] in N2:
                            for y in range(x+1, len(nums2)): 
                                if nums2[x] * nums2[y] == nums1[i]**2:
                                    tmp += 1
                                
                    H[nums1[i]**2] = tmp
                    ans += tmp
                    
                else:
                    ans += H[nums1[i]**2]
          
      
        H = {}
                    
        for i in range(len(nums2)):
            if nums2[i]**2 in D:
                if nums2[i]**2 not in H:
                    tmp = 0
                    for x in range(len(nums1)):
                        if nums2[i]**2 % nums1[x]==0 and (nums2[i]**2)//nums1[x] in N1:
                            for y in range(x+1, len(nums1)): 
                                if nums1[x] * nums1[y] == nums2[i]**2:
                                    tmp += 1
                                
                    H[nums2[i]**2] = tmp
                    ans += tmp
                    
                else:
                    ans += H[nums2[i]**2]
                    
        return ans
            
                
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # nums1.sort()
        # nums2.sort()
        
        
        def count(A, B):
            res = 0
            n1 = len(A)
            n2 = len(B)
            for i in range(n1):
                target = A[i]**2
                d = collections.defaultdict(int)
                for num in B:
                    if target/num in d:
                        res += d[target/num]
                    d[num] += 1
            return res
                        
            
            
            
        return count(nums1, nums2) + count(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        rev, n1, n2 = 0, Counter(nums1), Counter(nums2)
        
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                t = (nums1[i] * nums1[j])**(1/2)
                
                if t == int(t) and t in n2:
                    rev += n2[t]
        
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                t = (nums2[i] * nums2[j])**(1/2)
                
                if t == int(t) and t in n1:
                    rev += n1[t]
        
        return rev

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        cnt1, cnt2 = collections.Counter(nums1), collections.Counter(nums2)
        ans = 0
        for v1, l1 in list(cnt1.items()):
            for v2, l2 in list(cnt2.items()): 
                # only check half of it, 
                if v2 != v1 and v1 ** 2 / v2 in cnt2: 
                    ans += (l1 * l2 * cnt2[v1**2 / v2])
                elif v2 == v1: 
                    ans += (l1 * l2 * (l2-1) )
        for v1, l1 in list(cnt2.items()):
            for v2, l2 in list(cnt1.items()): 
                # only check half of it, 
                if v2 != v1 and v1 ** 2 / v2 in cnt1: 
                    ans += (l1 * l2 * cnt1[v1**2 / v2] )
                elif v2 == v1: 
                    ans += (l1 * l2 * (l2-1) )
        return int(ans / 2)
            
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        res = 0
        
        for i in range(len(nums1)):
            target = nums1[i]**2
            prev = collections.Counter()
            for j in range(len(nums2)):
                if target % nums2[j] != 0: continue
                val = target // nums2[j]
                if val in prev:
                    res += prev[val]
                prev[nums2[j]] += 1
        
        for i in range(len(nums2)):
            target = nums2[i]**2
            prev = collections.Counter()
            for j in range(len(nums1)):
                if target % nums1[j] != 0: continue
                val = target // nums1[j]
                if val in prev:
                    res += prev[val]
                prev[nums1[j]] += 1
        
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        set1 = set(nums1)
        set2 = set(nums2)
        lookup1 = defaultdict(int)

        def ncr(n,r):
            from math import factorial
            return factorial(n)//factorial(r) //factorial(n-r)
        
        def countTriplets(nums1,nums2):
            lookup = defaultdict(int)
            count = 0
            for index, val in enumerate(nums1):
                target = val**2
                lookup = defaultdict(int)
                for index2, val2 in enumerate(nums2):
                    if target % val2 == 0:
                        if target // val2 in lookup and target //val2 != val2:
                            count += lookup[target//val2]
                        elif target // val2 in lookup and target //val2 == val2:
                            count += lookup[target//val2]
                    lookup[val2]+=1
            return count
        
        # solving type 1
        count1 = countTriplets(nums1,nums2)
        count2 = countTriplets(nums2,nums1)
        return count1+count2

class Solution:
    def numTriplets(self, a: List[int], b: List[int]) -> int:
        n=len(a);m=len(b)
        pro1={}
        pro2={}
        for i in range(n):
            for j in range(n):
                if i!=j:
                    pro1[a[i]*a[j]]=pro1[a[i]*a[j]]+1 if a[i]*a[j] in pro1 else 1
        for i in range(m):
            for j in range(m):
                if i!=j:
                    pro2[b[i]*b[j]]=pro2[b[i]*b[j]]+1 if b[i]*b[j] in pro2 else 1           
        ans=0
        for i in range(n):
            if a[i]**2 in pro2:
                ans+=pro2[a[i]**2]//2
        for i in range(m):
            if b[i]**2 in pro1:
                ans+=pro1[b[i]**2] //2      
        return ans        

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def helper(l1, l2):
            ans = 0
            for e in l1:
                dp = Counter()
                tar = e**2
                for x in l2:
                    if tar%x == 0:
                        ans += dp[tar//x]
                    dp[x] += 1
            return ans
        
        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        A = collections.defaultdict(int)
        B = collections.defaultdict(int)
        
        ans = 0
        for i in nums1:
            a = i*i
            B.clear()
            for j in nums2:
                b = j*j
                
                x = a/j
                if x in B:
                    # print(x, a, j)
                    ans += B[x]
                
                y = b/i
                if y in A:
                    # print(i, b, y , j)
                    ans += A[y]
                
                B[j] += 1
            
            A[i] += 1
        
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        # x = [i for i in range(1000)]
        # y = [i for i in range(1000)]
        # ans = 0
        # for a in x:
        #     for b in y:
        #         ans += a*b % 1000000
        
        
        def cal(nums1, nums2):
            ans = 0
            for a in nums1:
                d = collections.defaultdict(lambda:0)
                sq = a*a
                for ib in range(0, len(nums2)):
                    b = nums2[ib]
                    if b == 0:
                        if a == 0:
                            ans += ib
                        else:
                            continue
                    if sq % b != 0:
                        continue
                    else:
                        c = sq/b
                        if c in d:
                            ans += d[c]
                    d[b] += 1
            print(ans)
            return ans
        
        return cal(nums1,nums2) + cal(nums2,nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums1,nums2):
            s = [n*n for n in nums1]
            count = 0
            d = collections.defaultdict(list)
            for i in range(len(nums2)):
                d[nums2[i]].append(i)
                
            for n in s:
                for i in range(len(nums2)):
                    if n%nums2[i] == 0 and n//nums2[i] in d:
                        if nums2[i] == n//nums2[i]:
                            count += len(d[n//nums2[i]])-1
                        else:
                            count += len(d[n//nums2[i]])
            return count//2
        return helper(nums1,nums2) + helper(nums2,nums1)

from collections import Counter
from itertools import combinations 
from math import sqrt
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        count1=Counter(nums1)
        count2=Counter(nums2)
        set1=set(nums1)
        set2=set(nums2)
        nums11=list([x*x for x in set1])
        nums22=list([x*x for x in set2])
        count=0
        for i,j in list(combinations(set1,2)):
            if i*j in nums22:
                count+=count2[sqrt(i*j)]*count1[i]*count1[j]
        for i,j in list(combinations(set2,2)):
            if i*j in nums11:
                count+=count1[sqrt(i*j)]*count2[i]*count2[j]
        for i in set1:
            if count1[i]>1 and i*i in nums22:
                count+=count1[i]*(count1[i]-1)*count2[i]//2
        for i in set2:
            if count2[i]>1 and i*i in nums11:
                count+=count2[i]*(count2[i]-1)*count1[i]//2
        return count



        # return count1, count2, set1, set2,nums11,nums22, list(combinations(set1,2))


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(l1,l2):
            res = 0
            for i in range(len(l1)):
                comp = dict()
                target = l1[i]**2
                
                for j in range(len(l2)):
                        if target/l2[j] in comp:
                            res+=comp[target/l2[j]]
                        comp[l2[j]] = comp.get(l2[j],0) + 1
            return res
        
        return helper(nums1,nums2) + helper(nums2,nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        nums1.sort()
        nums2.sort()
        for i in range(len(nums2)):
            ii = nums2[i]**2
            ar = {}
            for j in range(len(nums1)):
                # print(nums1[j], ii, ar)
                if ii%nums1[j] == 0:
                    g = ii//nums1[j]
                else:
                    ar[nums1[j]] = ar.get(nums1[j],0) + 1
                    continue
                
                # print(nums1[j], g, ii)
                if ar.get(g) is not None:
                    ans += ar[g]
                ar[nums1[j]] = ar.get(nums1[j],0) + 1
                
        for i in range(len(nums1)):
            ii = nums1[i]**2
            ar = {}
            for j in range(len(nums2)):
                # print(nums2[j], ii, ar, nums2)
                if ii%nums2[j] == 0:
                    g = ii//nums2[j]
                else:
                    ar[nums2[j]] = ar.get(nums2[j],0) + 1
                    continue
                
                # print(nums2[j], g, ii)
                if ar.get(g) is not None:
                    ans += ar[g]
                ar[nums2[j]] = ar.get(nums2[j],0) + 1
        return ans
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        nums1.sort()
        nums2.sort()
        
        def lowerbound(target, left, right, nums):
            while left < right:
                mid = left + (right - left) // 2

                if nums[mid] == target:
                    right = mid
                elif nums[mid] < target:
                    left = mid + 1
                else:
                    right = mid
            
            return left
        
        def higherbound(target, left, right, nums):
            while left < right:
                mid = left + (right - left) // 2
                
                if nums[mid] == target:
                    left = mid + 1
                elif nums[mid] < target:
                    left = mid + 1
                else:
                    right = mid
            
            return left
            
        
        @lru_cache(maxsize = None)
        def helper1(n):
            result = 0
            
            for i in range(len(nums1)):
                if n % nums1[i] != 0:
                    continue
                    
                target = n // nums1[i]
                
                # lower bound
                lower = lowerbound(target, i+1, len(nums1), nums1)
                higher = higherbound(target, i+1, len(nums1), nums1)
                
                result += (higher - lower)
                
            return result
        
        @lru_cache(maxsize = None)
        def helper2(n):
            result = 0
            
            for i in range(len(nums2)):
                if n % nums2[i] != 0:
                    continue
                    
                target = n // nums2[i]
                
                # lower bound
                lower = lowerbound(target, i+1, len(nums2), nums2)
                higher = higherbound(target, i+1, len(nums2), nums2)
                
                result += (higher - lower)
                
            return result
        
        
        result = 0
        for n in nums1:
            result += helper2(n*n)
        
        for n in nums2:
            result += helper1(n*n)
        
        
        return result
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.triplets(nums1,nums2)+self.triplets(nums2,nums1)
        
    def triplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        counter = Counter(nums2)
        for i in range(len(nums1)):
            target = nums1[i]**2
            
            for j in range(len(nums2)):
                if target/nums2[j] in counter:
                    if target/nums2[j] == nums2[j]:
                        count += counter[target/nums2[j]] - 1 
                    else:
                        count += counter[target/nums2[j]]
        return int(count/2)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dic1 = {}
        dic2 = {}
        s1 = []
        s2 = []
        r = 0
        n1 = len(nums1)
        n2 = len(nums2)
        for i in range(n1):
            r += self.helper(nums1[i] * nums1[i], nums2)
        for i in range(n2):
            r += self.helper(nums2[i] * nums2[i], nums1)
        
        return r
        
    def helper(self, prod, arr):
        d = {}
        r = 0
        for i in range(len(arr)):
            if prod % arr[i] == 0:
                if prod // arr[i] in d:
                    r += d[prod // arr[i]]
            d[arr[i]] = d.get(arr[i], 0) + 1
        return r

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def count(nums1, nums2):
            pairs = []
            N1, N2 = len(nums1), len(nums2)
            result = 0

            for i in range(N2):
                for j in range(i + 1, N2):
                    pairs.append((nums2[i], nums2[j]))
            
            Ns = collections.Counter(nums1)
            for u, v in pairs:
                if (u * v) ** 0.5 in Ns:
                    result += Ns[(u * v) ** 0.5]

            return result
        
        return count(nums1, nums2) + count(nums2, nums1)

from collections import Counter

class Solution:
        
    def search(self, nums1, nums2, counter):
        for i in range(len(nums1)):
            if nums1[i] ** 2 > nums2[-1] ** 2:
                break
            for j in range(i + 1, len(nums1)):
                if nums1[i] * nums1[j] > nums2[-1] ** 2:
                    break
                target = nums1[i] * nums1[j]
                self.rst += counter[target]

    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        if not nums1 or not nums2:
            return 0
        nums1.sort()
        nums2.sort()
        counter1 = Counter([x**2 for x in nums1])
        counter2 = Counter([x**2 for x in nums2])
        self.rst = 0
        self.search(nums1, nums2, counter2)
        self.search(nums2, nums1, counter1)
        return self.rst

                
                
                


from math import sqrt
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count1 = [0] * 100001
        count2 = [0] * 100001
        for i in nums1:
            count1[i] += 1
        for i in nums2:
            count2[i] += 1
        m = len(nums1)
        n = len(nums2)
        ans = 0
        for i in range(m-1):
            for j in range(i+1, m):
                sq = int(sqrt(nums1[i] * nums1[j]))
                if(sq**2 == nums1[i] * nums1[j]):
                    ans += count2[sq]
        for i in range(n-1):
            for j in range(i+1, n):
                sq = int(sqrt(nums2[i] * nums2[j]))
                if(sq**2 == nums2[i] * nums2[j]):
                    ans += count1[sq]
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ret1 = self.check(nums1, nums2)
        ret2 = self.check(nums2, nums1)
        
        return (ret1 + ret2)


    def check(self, n1 :List[int], n2 :List[int]):
        count_n2_org = Counter(n2)
        cnt = 0

        for i in range(len(n1)):
            square = n1[i]**2
            count_n2 = count_n2_org.copy()

            for j in range(len(n2)):
                if (square % n2[j] == 0):
                    target = square // n2[j]

                    if (count_n2[target] > 0):
                        count_n2[n2[j]] -= 1
                        cnt += count_n2[target]
        
        
        return cnt


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.helper(nums1, nums2) + self.helper(nums2, nums1)
        
    def helper(self, nums1, nums2):
        res = 0
        for n in nums1:
            cnt = {}
            for m in nums2:
                q, d = n * n % m, n * n // m 
                if q == 0 and d > 0:
                    if d in cnt:
                        res += cnt[d]
                    cnt[m] = cnt.get(m, 0) + 1
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import defaultdict
        count = 0
        Dict = defaultdict(int)
        for i in range(len(nums1)):
            num = nums1[i]*nums1[i]
            Dict.clear()
            for j in range(len(nums2)):
                if Dict[nums2[j]] > 0:
                    count += Dict[nums2[j]]
                if num % nums2[j] == 0:
                    x = num//nums2[j]
                    Dict[x] += 1
        Dict.clear()
        #print(count)
        for i in range(len(nums2)):
            num = nums2[i]*nums2[i]
            Dict.clear()
            for j in range(len(nums1)):
                if Dict[nums1[j]] > 0:
                    count += Dict[nums1[j]]
                if num % nums1[j] == 0:
                    x = num//nums1[j]
                    Dict[x] += 1
        return count
        
                
                
            


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0 
        
        dic1 = dict()
        for num in nums1:
            if num in dic1:
                dic1[num] += 1
            else:
                dic1[num] = 1
                
        dic2 = dict()
        for num in nums2:
            if num in dic2:
                dic2[num] += 1
            else:
                dic2[num] = 1
                     
        for num1 in nums1:
            square = num1 ** 2
            for num2 in nums2:
                if square / num2 in dic2:
                    if square / num2 == num2:
                        count += dic2[square / num2] - 1
                    else:
                        count += dic2[square / num2]
                        
        for num2 in nums2:
            square = num2 ** 2
            for num1 in nums1:
                if square / num1 in dic1:
                    if square / num1 == num1:
                        count += dic1[square / num1] - 1
                    else:
                        count += dic1[square / num1]
                        
        return int(count / 2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count1 = collections.Counter(nums1)
        count2 = collections.Counter(nums2)
        
        def cal(nums1, count2):
            ans = 0
            for n1 in nums1:
                sq = n1**2
                for n2 in sorted(count2):
                    if sq % n2 != 0 or sq // n2 not in count2: 
                        continue
                    c2 = sq // n2                        
                    if c2 < n2: 
                        break
                    elif c2 == n2 and count2[n2] > 1:
                        ans += math.comb(count2[n2], 2)
                    elif c2 > n2:
                        ans += count2[n2] * count2[c2]
                    
            return ans
        
        return cal(nums1, count2) + cal(nums2, count1)

class Solution:

    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def twoProduct(n, nums):
            counter = collections.Counter()
            res = 0
            for num in nums:
                if n % num == 0:
                    res += counter[n / num]
                counter[num] += 1
            return res
        res = 0
        for num in nums1:
            res += twoProduct(num*num, nums2)
        for num in nums2:
            res += twoProduct(num*num, nums1)
        return res

        
#         res = 0
#         d1 = collections.defaultdict(list)
#         for i, num in enumerate(nums1):
#             d1[num].append(i)
        
#         for i in range(len(nums2) - 1):
#             for j in range(i+1, len(nums2)):
#                 sqrt = (nums2[i]*nums2[j])**0.5
#                 if sqrt == int(sqrt) and sqrt in d1:
#                     res += len(d1[sqrt])
#         d2 = collections.defaultdict(list)
#         for i, num in enumerate(nums2):
#             d2[num].append(i)
        
#         for i in range(len(nums1) - 1):
#             for j in range(i+1, len(nums1)):
#                 sqrt = (nums1[i]*nums1[j])**0.5
#                 if sqrt == int(sqrt) and sqrt in d2:
#                     res += len(d2[sqrt])
#         return res


from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # nums2=sorted(nums2)
        # def isPresent(p, nums):
        #     start=0
        #     end=len(nums)-1
        #     while(start<end):
        def get_data(nums1,nums2):
            count=defaultdict(int)
            for i in range(len(nums2)):
                count[nums2[i]]+=1
            s=0
            for i in range(len(nums1)):
                for j in range(len(nums2)):
                    if (nums1[i]*nums1[i])%nums2[j]!=0:
                        continue
                    elif nums2[j]==(nums1[i]*nums1[i])//nums2[j]:   
                        s+=(count[(nums1[i]*nums1[i])//nums2[j]]-1)
                    else:
                        s+=count[(nums1[i]*nums1[i])//nums2[j]]
            return s//2
        return get_data(nums1,nums2)+get_data(nums2, nums1)


class Solution:
    def numTriplets(self, a: List[int], b: List[int]) -> int:
        
        # i^2 / k == j
        
        def count(a, b):
            
            ret = 0
            
            for x in a:
                
                c = Counter()
                
                for y in b:
                    square = x*x
                    
                    if square % y == 0:
                        ret += c[square // y]
                    
                    c[y] += 1
            
            return ret
        
        return count(a,b) + count(b,a)


class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        countA, countB = Counter(A), Counter(B)
        res = 0
        for i in range(len(A)):
            x = A[i] * A[i]
            for j in range(len(B)):
                if x % B[j] == 0 and x // B[j] in countB:
                    if B[j] * B[j] == x:
                        res += (countB[x//B[j]] - 1)
                        # print(B[j], countB[B[j]] - 1)
                    else:
                        res += countB[x//B[j]]
                        # print(B[j], x, countB[B[j]])
        # print(res)
        for i in range(len(B)):
            x = B[i] * B[i]
            for j in range(len(A)):
                if x % A[j] == 0 and x // A[j] in countA:
                    if A[j] * A[j] == x:
                        res += (countA[x//A[j]] - 1)
                    else:
                        res += countA[x//A[j]]
        return res//2


class Solution:
    def find(self, nums, target):
        seen = collections.defaultdict(int)
        res = 0
        for i in nums:
            if target % i == 0 and target/i in seen:
                res += seen[target/i]
            seen[i] += 1
        return res
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        res = 0
        for i in nums1:
            target = i * i
            res += self.find(nums2, target)
        for i in nums2:
            target = i * i
            res += self.find(nums1, target)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        
        res = 0
        for a in nums1:
            sq = a * a
            cnt = Counter()
            for b in nums2:
                if sq % b == 0 and sq//b in cnt:
                    res += cnt[sq//b]
                cnt[b] += 1
        
        for a in nums2:
            sq = a * a
            cnt = Counter()
            for b in nums1:
                if sq % b == 0 and sq//b in cnt:
                    res += cnt[sq//b]
                cnt[b] += 1
        return res
                    
        
        
        
        
        
        


class Solution:
    # O(N*M) Solution
    def numTriplets(self, nums1, nums2): 
        res = 0
        for n in nums1:
            res += self.twoProduct(n*n, nums2)
        for n in nums2:
            res += self.twoProduct(n*n, nums1)
        
        return res
    
    
    def twoProduct(self, target, nums):
        count = 0
        compFreq = {} # key: compliment (target/cur), element: freq of this compliment (NOT idx!!!)
        for i in range(len(nums)):
            comp = target / nums[i]
            if comp == int(comp): # is comp is a float, no need to proceed
                if nums[i] in compFreq:
                    count += compFreq[nums[i]]
                
                if comp in compFreq: # update freq
                    compFreq[comp] += 1
                else:
                    compFreq[comp] = 1
        return count
                
                
    '''
    # O(N^2) Solution
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int: 
        res = 0
        
        # freq is dict that has key=n^2, element=frequency of n^2 occur
        # if there are duplicate in nums1=[2,2], and nums2=[1,4], there are 2 cases in stead on 1
        freq1 = {}
        freq2 = {}
        for n in nums1:
            if n*n in freq1:
                freq1[n*n] += 1
            else:
                freq1[n*n] = 1
        for n in nums2:
            if n*n in freq2:
                freq2[n*n] += 1
            else:
                freq2[n*n] = 1
        
        for b in range(len(nums2)-1):
            for c in range(b+1, len(nums2)):
                if (nums2[b] * nums2[c]) in freq1:
                    res += freq1[nums2[b] * nums2[c]]
                    
        for b in range(len(nums1)-1):
            for c in range(b+1, len(nums1)):
                if (nums1[b] * nums1[c]) in freq2:
                    res += freq2[nums1[b] * nums1[c]]
        return res
    '''

from bisect import bisect_right
from collections import defaultdict

def sol(inp1, inp2):
    values1 = defaultdict(list)
    values2 = defaultdict(list)
    inp1.sort()
    inp2.sort()
    for i1, v1 in enumerate(inp1):
        values1[v1].append(i1)
    for i2, v2 in enumerate(inp2):
        values2[v2].append(i2)
    count = 0
    for i1, v1 in enumerate(inp1):
        for i2, v2 in enumerate(inp2):
            if v2 > v1:
                break
            matches = values2[(v1*v1)/v2]
            ins = bisect_right(matches, i2)
            count += len(matches) - ins
    for i2, v2 in enumerate(inp2):
        for i1, v1 in enumerate(inp1):
            if v1 > v2:
                break
            matches = values1[(v2*v2)/v1]
            ins = bisect_right(matches, i1)
            count += len(matches) - ins
    return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return sol(nums1, nums2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import defaultdict
        import math
        cnt1=defaultdict(int)
        cnt2=defaultdict(int)
        for k in range(len(nums1)-1):
            for j in range(k+1,len(nums1)):
                temp=nums1[k]*nums1[j]
                if temp-(math.ceil((temp)**0.5))**2==0:
                    cnt1[temp]+=1
        
        for k in range(len(nums2)-1):
            for j in range(k+1,len(nums2)):
                temp=nums2[k]*nums2[j]
                if temp-(math.ceil((temp)**0.5))**2==0:
                    cnt2[temp]+=1
        print(cnt1,cnt2)      
        res=0            
        for t in nums1:
            res+=cnt2[t**2]
        for t in nums2:
            res+=cnt1[t**2]
            
        return res
        
            
            
        
                    
        
            
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        num1_dict = collections.defaultdict(int)
        num2_dict = collections.defaultdict(int)
        for num in nums1:
            num1_dict[num] += 1
        for num in nums2:
            num2_dict[num] += 1
        
        res = 0
        for num in num1_dict:
            double = num**2
            for num2 in num2_dict:
                if double%num2 == 0 and double//num2 in num2_dict:
                    if num2 == double//num2:
                        res += num2_dict[num2] * (num2_dict[num2]-1)*num1_dict[num]
                        
                    else:
                        res += num2_dict[num2] * (num2_dict[double//num2])*num1_dict[num]
                        
                        

                        
        for num in num2_dict:
            double = num**2
            for num2 in num1_dict:
                if double%num2 == 0 and double//num2 in num1_dict:
                    if num2 == double//num2:
                        res += num1_dict[num2] * (num1_dict[num2]-1)*num2_dict[num]
                    else:
                        res += num1_dict[num2] * (num1_dict[double//num2])  *num2_dict[num]
        return res//2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        nums1.sort()
        nums2.sort()
        
        def lowerbound(target, left, right, nums):
            while left < right:
                mid = left + (right - left) // 2

                if nums[mid] == target:
                    right = mid
                elif nums[mid] < target:
                    left = mid + 1
                else:
                    right = mid
            
            return left
        
        def higherbound(target, left, right, nums):
            while left < right:
                mid = left + (right - left) // 2
                
                if nums[mid] == target:
                    left = mid + 1
                elif nums[mid] < target:
                    left = mid + 1
                else:
                    right = mid
            
            return left
            
    
        def helper(n, nums, memo):
            if n in memo:
                return memo[n]
            
            result = 0
            
            for i in range(len(nums)):
                if n % nums[i] != 0:
                    continue
                    
                target = n // nums[i]
                
                lower = lowerbound(target, i+1, len(nums), nums)
                higher = higherbound(target, i+1, len(nums), nums)
                
                result += (higher - lower)
            
            memo[n] = result
            return result
        
        result = 0
        
        memo1 = {}
        for n in nums1:
            result += helper(n*n, nums2, memo1)
        
        memo2 = {}
        for n in nums2:
            result += helper(n*n, nums1, memo2)
        
        
        return result
            


class Solution:
    # O(N*M) Solution
    def numTriplets(self, nums1, nums2): 
        res = 0
        for n in nums1:
            res += self.twoProduct(n*n, nums2)
        for n in nums2:
            res += self.twoProduct(n*n, nums1)
        
        return res
    
    
    def twoProduct(self, target, nums):
        count = 0
        compFreq = {} # key: compliment (target/cur), element: freq of this compliment (NOT idx!!!)
        cList = set()
        for i in range(len(nums)):
            comp = target / nums[i]
            if comp == int(comp): # is comp is a float, no need to proceed
                if nums[i] in compFreq:
                    count += compFreq[nums[i]]
                
                    
                
                if comp in compFreq: # update freq
                    compFreq[comp] += 1
                else:
                    compFreq[comp] = 1
        return count
                
                
    '''
    # O(N^2) Solution
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int: 
        res = 0
        
        # freq is dict that has key=n^2, element=frequency of n^2 occur
        # if there are duplicate in nums1=[2,2], and nums2=[1,4], there are 2 cases in stead on 1
        freq1 = {}
        freq2 = {}
        for n in nums1:
            if n*n in freq1:
                freq1[n*n] += 1
            else:
                freq1[n*n] = 1
        for n in nums2:
            if n*n in freq2:
                freq2[n*n] += 1
            else:
                freq2[n*n] = 1
        
        for b in range(len(nums2)-1):
            for c in range(b+1, len(nums2)):
                if (nums2[b] * nums2[c]) in freq1:
                    res += freq1[nums2[b] * nums2[c]]
                    
        for b in range(len(nums1)-1):
            for c in range(b+1, len(nums1)):
                if (nums1[b] * nums1[c]) in freq2:
                    res += freq2[nums1[b] * nums1[c]]
        return res
    '''

from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        da=Counter(nums1)
        db=Counter(nums2)
        cnt=0
        #type1
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                p=nums2[i]*nums2[j]
                if math.isqrt(p) ** 2 == p and math.isqrt(p) in da:
                    cnt+=da[int(math.sqrt(p))]
        #type2
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                p=nums1[i]*nums1[j]
                if math.isqrt(p) ** 2 == p and math.isqrt(p) in db:
                    cnt+=db[int(math.sqrt(p))]
        return cnt
                    

        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        memo1, memo2 = collections.Counter(), collections.Counter()
        for a, b in itertools.combinations(nums1, 2):
            temp = int(math.sqrt(a * b))
            if temp ** 2 == a * b:
                memo1[temp] += 1
        for a, b in itertools.combinations(nums2, 2):
            temp = int(math.sqrt(a * b))
            if temp ** 2 == a * b:
                memo2[temp] += 1
        return sum(memo2[num] for num in nums1) + sum(memo1[num] for num in nums2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        r = 0
        c = Counter()
        for i in nums1:
            if i in c:
                r += c[i]
            for j in nums2:
                c[j*j/i] += 1
                
        c = Counter()
        for i in nums2:
            if i in c:
                r += c[i]
            for j in nums1:
                c[j*j/i] += 1
        return r

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sq1 = defaultdict(list)
        pd1 = defaultdict(list)
        sq2 = defaultdict(list)
        pd2 = defaultdict(list)
        
        for i in range(0,len(nums1)):
            n1 = nums1[i]
            sq1[n1*n1].append(i)
            for j in range(i+1, len(nums1)):
                n2 = nums1[j]
                pd1[n1*n2].append([i,j])
                
        for i in range(0,len(nums2)):
            n1 = nums2[i]
            sq2[n1*n1].append(i)
            for j in range(i+1, len(nums2)):
                n2 = nums2[j]
                pd2[n1*n2].append([i,j])
        
        type1 = 0
        type2 = 0
        
        for sq in sq1:
            if sq in pd2:
                type1 += (len(sq1[sq])*len(pd2[sq]))
        for sq in sq2:
            if sq in pd1:
                type2 += (len(sq2[sq])*len(pd1[sq]))   
        return type1 + type2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        n = len(nums1)
        m = len(nums2)
        sq1 = list(map(lambda x:x**2,nums1))
        sq2 = list(map(lambda x:x**2,nums2))
        d1 = dict()
        d2 = dict()
        for num1 in list(set(nums1)):
            d1[num1] = dict()
            for i in range(n):
                if nums1[i] == num1:
                    if i == 0:
                        d1[num1][i] = 1
                    else:
                        d1[num1][i] = d1[num1][i-1]+1
                else:
                    if i == 0:
                        d1[num1][i] = 0
                    else:
                        d1[num1][i] = d1[num1][i-1]
        
        for num2 in list(set(nums2)):
            d2[num2] = dict()
            for i in range(m):
                if nums2[i] == num2:
                    if i == 0:
                        d2[num2][i] = 1
                    else:
                        d2[num2][i] = d2[num2][i-1]+1
                else:
                    if i == 0:
                        d2[num2][i] = 0
                    else:
                        d2[num2][i] = d2[num2][i-1]
        
        for i in range(n):
            for j in range(m-1):
                tmp = sq1[i]//nums2[j]
                if sq1[i]%nums2[j] == 0:
                    if tmp not in d2:
                        continue
                    ans += d2[tmp][m-1] - d2[tmp][j]
        
        for j in range(m):
            for i in range(n-1):
                tmp = sq2[j]//nums1[i]
                if sq2[j]%nums1[i] == 0:
                    if tmp not in d1:
                        continue
                    ans += d1[tmp][n-1] - d1[tmp][i]
        return ans

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0

        for n in nums1:
            t = defaultdict(int)
            for m in nums2:
                if (n*n) % m == 0 and ((n*n) // m) in t:
                    count += t[(n*n) // m]
                t[m] += 1
        
        for n in nums2:
            t = defaultdict(int)
            for m in nums1:
                if (n*n) % m == 0 and ((n*n) // m) in t:
                    count += t[(n*n) // m]
                t[m] += 1    

        return count
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.helper(nums1, nums2) + self.helper(nums2, nums1)
    
    def helper(self, arr1, arr2):
        res = 0
        for num in arr1:
            res += self.twoProduct(num * num, arr2)
        return res
    
    def twoProduct(self, target, arr):
        visited = {}
        res = 0
        for num in arr:
            if not num:
                continue
            if target % num == 0 and target // num in visited:
                res += visited[target // num]
            if num not in visited:
                visited[num] = 1
            else:
                visited[num] += 1
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
               
        res = 0
        cnt1 = collections.Counter()
        for j in range(len(nums2)):
            for i in range(len(nums1)):
                s = nums1[i]**2
                if s%nums2[j] == 0 and s//nums2[j] in cnt1:
                    res += cnt1[s//nums2[j]]    
                
            cnt1[nums2[j]] +=1
                    
        cnt2 = collections.Counter()
        for j in range(len(nums1)):
            for i in range(len(nums2)):
                s = nums2[i]**2
                if s%nums1[j] == 0 and s//nums1[j]  in cnt2:
                    res += cnt2[ s//nums1[j] ]    
                
            cnt2[nums1[j]] +=1 
                    
        return res
        
                    
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        count=self.counttrip(nums1,nums2)
        
        count+=self.counttrip(nums2,nums1)
        return int(count)
        
    def counttrip(self,nums1,nums2):
        
        count =0
        seen=defaultdict(int)
        for i in nums1:
            
            
            target=i*i
            if(target in seen):
                count+=seen[target]
                continue
            localcount=0
            dictn=defaultdict(int)
            for j,x in enumerate(nums2):
                rem = target/x
                if(rem in dictn):
                    localcount+=dictn[rem]
                dictn[x]+=1
            seen[target]+=localcount
            count+=localcount
        return count

class Solution:
    def numTriplets(self, nums1, nums2): 
        res = 0
        for n in nums1:
            res += self.twoProduct(n*n, nums2)
        for n in nums2:
            res += self.twoProduct(n*n, nums1)
        
        return res
    
    
    def twoProduct(self, target, nums):
        count = 0
        compFreq = {}
        for i in range(len(nums)):
            comp = target / nums[i]
            if comp == int(comp): # is comp is a float, no need to proceed
                if nums[i] in compFreq:
                    count += compFreq[nums[i]]
                
                if comp in compFreq:
                    compFreq[comp] += 1
                else:
                    compFreq[comp] = 1
        return count
                
                
    '''
    # O(N^2) Solution
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int: 
        res = 0
        
        # freq is dict that has key=n^2, element=frequency of n^2 occur
        # if there are duplicate in nums1=[2,2], and nums2=[1,4], there are 2 cases in stead on 1
        freq1 = {}
        freq2 = {}
        for n in nums1:
            if n*n in freq1:
                freq1[n*n] += 1
            else:
                freq1[n*n] = 1
        for n in nums2:
            if n*n in freq2:
                freq2[n*n] += 1
            else:
                freq2[n*n] = 1
        
        for b in range(len(nums2)-1):
            for c in range(b+1, len(nums2)):
                if (nums2[b] * nums2[c]) in freq1:
                    res += freq1[nums2[b] * nums2[c]]
                    
        for b in range(len(nums1)-1):
            for c in range(b+1, len(nums1)):
                if (nums1[b] * nums1[c]) in freq2:
                    res += freq2[nums1[b] * nums1[c]]
        return res
    '''

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(alist,blist):
            res = 0
            for a in alist:
                bset = collections.Counter()
                a2 = a*a
                for b in blist:
                    if a2/b in bset: res+=bset[a2/b]
                    bset[b]+=1
            return res
        return helper(nums1,nums2)+helper(nums2,nums1)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        for i in range(len(nums1)):
            h1 = {}
            target = nums1[i] * nums1[i]
            for j in range(len(nums2)):
                if target/nums2[j] in h1:
                    ans += h1[target/nums2[j]]
                if nums2[j] in h1:
                    h1[nums2[j]] += 1
                else:
                    h1[nums2[j]] = 1
                
                
        for i in range(len(nums2)):
            h2 = {}
            target = nums2[i] * nums2[i]
            for j in range(len(nums1)):
                if target/nums1[j] in h2:
                    ans += h2[target/nums1[j]]
                if nums1[j] in h2:
                    h2[nums1[j]] += 1
                else:
                    h2[nums1[j]] = 1        

        return ans
    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        set1 = Counter(nums1)
        set2 = Counter(nums2)
        N1 = len(nums1)
        N2 = len(nums2)
        n1sq = [n*n for n in nums1]
        n2sq = [n*n for n in nums2]
        ntr = 0
        for i1 in range(N1): 
            for i2 in range(N2): 
                if n1sq[i1] % nums2[i2] == 0: 
                    if nums1[i1] != nums2[i2] and (n1sq[i1]//nums2[i2]) in set2: 
                        ntr += 0.5*set2[n1sq[i1]//nums2[i2]]
                    elif nums1[i1] == nums2[i2]: 
                        ntr += 0.5*(set2[nums2[i2]] - 1)
                if n2sq[i2] % nums1[i1] == 0: 
                    if nums2[i2] != nums1[i1] and (n2sq[i2]//nums1[i1]) in set1: 
                        ntr += 0.5*set1[n2sq[i2]//nums1[i1]]
                    elif nums2[i2] == nums1[i1]: 
                        ntr += 0.5*(set1[nums1[i1]]-1)
        return round(ntr)
        


class Solution:
    def productPresent(self, numbers , required):
        result = 0
        count = collections.defaultdict(int)
        for number in numbers:
            count[number] += 1
        
        for number in numbers:
            if required % number != 0:
                continue
            keyRequired = required // number
            if keyRequired in count and count[keyRequired] > 0:
                if keyRequired == number:
                    result += (count[keyRequired] - 1)
                else:
                    result += count[keyRequired]
            count[number] -= 1
        
        return result
                    
                    
        
        
            
            
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        for i in (nums1):
            required = i * i
            result += self.productPresent(nums2,required)
        
        for i in (nums2):
            required = i * i
            result += self.productPresent(nums1,required)
        
        return result
        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ret1 = self.check(nums1, nums2)
        ret2 = self.check(nums2, nums1)
        
        return (ret1 + ret2)


    def check(self, n1 :List[int], n2 :List[int]):
        cnt = 0

        for i in range(len(n1)):
            square = n1[i]**2
            count_n2 = Counter(n2)

            for j in range(len(n2)):
                if (square % n2[j] == 0):
                    target = square // n2[j]

                    if (count_n2[target] > 0):
                        count_n2[n2[j]] -= 1
                        cnt += count_n2[target]
        
        
        return cnt


class Solution:
    def count(self, nums1: List[int], nums2: List[int]) -> int:
        c = 0
        for n in nums1:
            sq = n ** 2
            counter = Counter()
            for k in nums2:
                if sq % k == 0:
                    c += counter[sq // k]
                counter[k] += 1
        return c

    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.count(nums1, nums2) + self.count(nums2, nums1)

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ret = 0
        
        h1 = defaultdict(int)
        h2 = defaultdict(int)
        for x in nums1:
            h1[x] += 1
        for x in nums2:
            h2[x] += 1
        
        for x in nums1:
            for y in nums2:
                if x*x/y != x*x//y:
                    continue
                key = x*x//y
                if h2[key] > 0:
                    if key==y:
                        ret += h2[key]-1
                    else:
                        ret += h2[key]
        
        for x in nums2:
            for y in nums1:
                if x*x/y != x*x//y:
                    continue
                key = x*x//y
                if h1[key] > 0:
                    if key==y:
                        ret += h1[key]-1
                    else:
                        ret += h1[key]
                        
        return ret//2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        def helper(l1,l2):
            nonlocal ans
            c = Counter(l2)
            for x in l1:
                num = x*x
                c2 = c.copy()
                for i in range(len(l2)):
                    curr = l2[i]
                    c2[curr] -= 1
                    # if c2[curr] == 0:
                    #     c2.pop(curr)
                    # print(num,curr,c2)
                    if num%curr == 0 and num//l2[i] in c2:
                        ans += c2[num//l2[i]]
                        
        helper(nums1,nums2)
        helper(nums2,nums1)
        return ans
        
                    


from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        jk1, jk2 = defaultdict(set), defaultdict(set)
        for j in range(len(nums1)):
            for k in range(j + 1, len(nums1)):
                jk1[nums1[j] * nums1[k]].add((j, k))
        for j in range(len(nums2)):
            for k in range(j + 1, len(nums2)):
                jk2[nums2[j] * nums2[k]].add((j, k))
        
        
        res = 0
        for i in range(len(nums1)):
            res += len(jk2[nums1[i] ** 2])
        for i in range(len(nums2)):
            res += len(jk1[nums2[i] ** 2])
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def getRes(arr1, arr2):
            count = 0
            n = len(arr2)
            max2 = arr2[-1]
            for i in range(len(arr1)):
                if arr1[i] > max2: break
                target = arr1[i] ** 2
                
                seen = collections.defaultdict(int)
                for j in range(n):
                    if target / arr2[j] in seen:
                        count += seen[target / arr2[j]]
                    seen[arr2[j]] += 1
                        
            
            return count
        nums1.sort()
        nums2.sort()
        return getRes(nums1, nums2) + getRes(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ret = 0
        m, n = len(nums1), len(nums2)
        _map1, _map2 = Counter(nums1), Counter(nums2)
        for i in range(m):
            nums2_map = {**_map2}
            for j in range(n):
                nums2_map[nums2[j]] -= 1
                target = nums1[i] * nums1[i] / nums2[j]
                if nums2_map.get(target, 0) > 0:
                    ret += nums2_map.get(target, 0)
    
        for i in range(n):
            nums1_map = {**_map1}
            for j in range(m):
                nums1_map[nums1[j]] -= 1
                target = nums2[i] * nums2[i] / nums1[j]
                if nums1_map.get(target, 0) > 0:
                    ret += nums1_map.get(target, 0)
        
        return ret

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        d = {}
        drev = {}
        
        for i,x in enumerate(nums2):
            if x in drev:
                drev[x].add(i)
            else:
                drev[x] = {i}
                
        
        # print(d)
        
        
        for idx1,x in enumerate(nums1):
            i2 = x*x
            d = drev.copy()
            drev.clear()
            for idx,j in enumerate(nums2):
                d[j].remove(idx)
                if j in drev:drev[j].add(idx)
                else: drev[j] = {idx}
                
                if i2%j == 0:
                    k = i2//j
                    if k in d:
                        ans+=len(d[k])                                
                                
                                
                                
        d = {}
        drev = {}
        
        for i,x in enumerate(nums1):
            if x in drev:
                drev[x].add(i)
            else:
                drev[x] = {i}
                
        
        # print(d)
        
        
        for idx1,x in enumerate(nums2):
            i2 = x*x
            d = drev.copy()
            drev.clear()
            for idx,j in enumerate(nums1):
                d[j].remove(idx)
                if j in drev:drev[j].add(idx)
                else: drev[j] = {idx}
                
                if i2%j == 0:
                    k = i2//j
                    if k in d:
                        ans+=len(d[k])           
        
                                
                                
        return ans
                                
    
                    
                


class Solution:
    def numTriplets(self, a: List[int], b: List[int]) -> int:
        map1 = {}
        map2 = {}

        for i in range(len(a)):
            for j in range(len(a)):
                if i!=j:
                    if a[i]*a[j] not in map1.keys():
                        map1[a[i]*a[j]]= 0
                    map1[a[i]*a[j]]+=1

        for i in range(len(b)):
              for j in range(len(b)):
                if i!=j:
                    if b[i]*b[j] not in map2.keys():
                        map2[b[i]*b[j]]= 0
                    map2[b[i]*b[j]]+=1

        count = 0
        for i in a:
            if i*i in map2.keys():
                count+=map2[i*i]

        for i in b:
            if i*i in map1.keys():
                count+=map1[i*i]
                
        return count//2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = collections.Counter(nums1)
        d2 = collections.Counter(nums2)        
        ans = 0
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                p = nums1[i]*nums1[j]
                if (int(math.sqrt(p)))**2 == p and int(math.sqrt(p)) in d2:
                    ans+=d2[int(math.sqrt(p))]
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                p = nums2[i]*nums2[j]
                if (int(math.sqrt(p)))**2 == p and int(math.sqrt(p)) in d1:
                    ans+=d1[int(math.sqrt(p))]
        return ans


class Solution:
    def numTriplets(self, A: List[int], B: List[int]) -> int:
        def find(X,Y):
            res = 0
            for x in X:
                have = collections.Counter(Y)
                for i, y in enumerate(Y):
                    have[y] -= 1
                    if x*x % y == 0:  
                        res += have[x*x//y]
            return res
        return find(A,B) + find(B, A)
        


class Solution:
    
    def all_products(self, int_list):
        res_list = []
        for idx,i in enumerate(int_list):
            for j in int_list[idx+1:]:
                res_list.append(i*j)
        return res_list
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        squared_nums1 = [i**2 for i in nums1]
        squared_nums2 = [i**2 for i in nums2]
        products_nums1 = self.all_products(nums1)
        products_nums2 = self.all_products(nums2)
        # print (squared_nums1, squared_nums2, products_nums1, products_nums2)
        for i in set(squared_nums2):
            c1 = squared_nums2.count(i)
            c2 = products_nums1.count(i)
            res += c1 * c2
        for j in set(squared_nums1):
            d1 = squared_nums1.count(j)
            d2 = products_nums2.count(j)
            res += d1 * d2
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1 = list(Counter(nums1).items())
        nums2 = list(Counter(nums2).items())
        def find(target, count1, arr):
            seen = Counter()
            ans = 0
            for a, count2 in arr:
                if target % a == 0:
                    if (b := target // a) != a:
                        ans += count1 * count2 * seen[b]
                    else:
                        ans += count1 * math.comb(count2, 2)
                seen[a] += count2
            return ans

        return sum(find(a*a, c, nums2) for a, c in nums1) + sum(find(a*a, c, nums1) for a, c in nums2)

class Solution:
    
    
    
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        self.count = 0
        
        def computeCount(nums1, nums2):
            hashMap = {}
            for i in range(len(nums1)):
                checkNum = nums1[i] ** 2
                for j in range(len(nums2)):
                    modulus = checkNum/nums2[j]
                    if modulus in hashMap:
                        self.count += hashMap[modulus]
                    if nums2[j] in hashMap:
                        hashMap[nums2[j]] += 1
                    else:
                        hashMap[nums2[j]] = 1             
                hashMap.clear()

        computeCount(nums1, nums2)
        computeCount(nums2,nums1)
        return self.count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def twoProduct(target, nums) -> int:
            goal = defaultdict(list)
            tot = 0
            for i in range(len(nums)):
                if len(goal[nums[i]]) != 0:
                    tot += len(goal[nums[i]])
                goal[target/(nums[i])].append(i)
            
            return tot
        
        count = 0
        for n in nums1:
            count += twoProduct(n*n, nums2)
        
        for n in nums2:
            count += twoProduct(n*n, nums1)
        
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        one = [i**2 for i in nums1]
        two = [j**2 for j in nums2]
        self.cnt = 0
        d1 = collections.defaultdict(int)
        self.calculate(one,nums2)
        self.calculate(two,nums1)
        return self.cnt
    def calculate(self,square,nums):
        for i in range(len(square)):
            target = square[i]
            d = collections.defaultdict(list)
            for j in range(len(nums)):
                if target%nums[j]==0 and int(target/nums[j]) in d:
                    # print(target,nums[j],d[nums[j]])
                    self.cnt+=len(d[target/nums[j]])
                d[nums[j]].append(j)
                # print(target,d)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def helper(a, b):
            res = 0
            for num in a:
                tar = num ** 2
                cnt = collections.defaultdict(int)
                for x in b:
                    res += cnt[tar / x]
                    cnt[x] += 1
            return res
    
        return helper(nums1, nums2) + helper(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        if not nums1 or not nums2:
            return 0
        
        return self.helper(nums1, nums2) + self.helper(nums2, nums1)
    
    def helper(self, nums1, nums2):
        lookup = {}
        count = 0
        for num2 in nums2:
            for num1 in nums1:
                square = num1**2
                mod = square%num2
                divide = square//num2
                if square >= num2 and mod == 0 and divide in lookup:
                    count += lookup[divide]
            if num2 not in lookup:
                lookup[num2] = 0
            lookup[num2] += 1
        return count

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        '''Input: nums1 = [7,4], nums2 = [5,2,8,9]
        Output: 1
        Explanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8). 
        '''
        if not nums1 or not nums2:
            return 0
        
        res = 0
        newlist1 = collections.defaultdict(set)
        newlist2 = collections.defaultdict(set)
        
        
        for i in range(len(nums2)-1):
            for j in range(i+1, len(nums2)):
                key = nums2[i]*nums2[j]
                newlist1[key].add((i, j))
                
        for i in range(len(nums1)-1):
            for j in range(i+1, len(nums1)):
                key = nums1[i]*nums1[j]
                newlist2[key].add((i, j))
        # print(newlist)
        
        for n in nums1:
            if n**2 in newlist1:
                res += len(newlist1[n**2])
        for n in nums2:
            if n**2 in newlist2:
                res += len(newlist2[n**2])
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        table1 = {}
        table2 = {}
        res = 0
        
        for n in nums1:
            square = n * n
            table = {}
            for j, m in enumerate(nums2):
                if square % m == 0:
                    remainder = square // m
                    if remainder in table:
                        # print(square, m, remainder, table)
                        res += table[remainder]
                if m not in table:
                    table[m] = 0
                table[m] += 1
                
        for n in nums2:
            square = n * n
            table = {}
            for j, m in enumerate(nums1):
                if square % m == 0:
                    remainder = square // m
                    if remainder in table:
                        # print(square, m, remainder, table)

                        res += table[remainder]
                if m not in table:
                    table[m] = 0
                table[m] += 1  
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1Counter, nums2Counter, result = Counter(nums1), Counter(nums2), 0
        
        def isPerfectSquare(n):
            squareRoot = math.sqrt(n)
            return {
                'status': squareRoot - floor(squareRoot) == 0,
                'value': int(floor(squareRoot))
            }
        
        for num2j, num2k in combinations(nums2, 2):
            perfectSquare = isPerfectSquare(num2j * num2k)
            if perfectSquare['status']:
                result += nums1Counter[perfectSquare['value']]
        for num1j, num1k in combinations(nums1, 2):
            perfectSquare = isPerfectSquare(num1j * num1k)
            if perfectSquare['status']:
                result += nums2Counter[perfectSquare['value']]
        return result

from itertools import combinations
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sq1, sq2 = [num ** 2 for num in nums1], [num ** 2 for num in nums2]
        prod1, prod2 = [combo[0] * combo[1] for combo in combinations(nums1, 2)], [combo[0] * combo[1] for combo in combinations(nums2, 2)]
        result = 0
        for sq in set(sq1):
            result += sq1.count(sq) * prod2.count(sq)
        for sq in set(sq2):
            result += sq2.count(sq) * prod1.count(sq)
        return result

from collections import defaultdict
from typing import List


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # ハッシュ化
        h1 = {}
        h2 = {}

        for n in nums1:
            if n in h1:
                h1[n] += 1
            else:
                h1[n] = 1
        for n in nums2:
            if n in h2:
                h2[n] += 1
            else:
                h2[n] = 1

        count = 0

        # Type1
        for n in nums1:
            n2 = n * n
            for v in list(h2.keys()):
                q, m = divmod(n2, v)
                if m != 0 or q not in h2:
                    continue

                l1 = h2[v]
                if v == q:
                    if l1 > 1:
                        # l1個の中から2個選ぶ組み合わせの数
                        count += (l1 * (l1-1))
                else:
                    l2 = h2[q]
                    count += l1 * l2

        # Type2
        for n in nums2:
            n2 = n * n
            for v in list(h1.keys()):
                q, m = divmod(n2, v)
                if m != 0 or q not in h1:
                    continue

                l1 = h1[v]
                if v == q:
                    if l1 > 1:
                        # l1個の中から2個選ぶ組み合わせの数
                        count += (l1 * (l1-1))
                else:
                    l2 = h1[q]
                    count += l1 * l2

        return int(count / 2)


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        for i in range(len(nums1)):
            dic = collections.defaultdict(int)
            for j in range(len(nums2)):
                target = (nums1[i] **2) / nums2[j]
                if target in dic:
                    result += dic[target]
                dic[nums2[j]] += 1
                
        for i in range(len(nums2)):
            dic = collections.defaultdict(int)
            for j in range(len(nums1)):
                target = nums2[i] **2 / nums1[j]
                if target in dic:
                    result += dic[target]
                dic[nums1[j]] += 1
        return result

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:     
        res = 0
        res += sum(self.get_target_products(n * n, nums2) for n in nums1)
        res += sum(self.get_target_products(n * n, nums1) for n in nums2)
        return res
    
    def get_target_products(self, target, nums):
        d = collections.Counter()
        res = 0
        for i in range(len(nums)):
            if target / nums[i] in d:
                res += d[target / nums[i]]
            d[nums[i]] += 1
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # nums1.sort()
        # nums2.sort()
        count=0
        for i in range(len(nums1)):
            target=nums1[i]**2
            temp=defaultdict(int)
            for j in range(len(nums2)):
                if (target/nums2[j]) in list(temp.keys()):
                    count+=temp[target/nums2[j]]
                temp[nums2[j]]+=1
                        
        for i in range(len(nums2)):
            target=nums2[i]**2
            temp=defaultdict(int)
            for j in range(len(nums1)):
                if (target/nums1[j]) in list(temp.keys()):
                    count+=temp[target/nums1[j]]
                temp[nums1[j]]+=1
        # for i in range(len(nums1)):
        #     s2=nums1[i]**2
        #     first,last=0,len(nums2)-1
        #     while nums2[last//2]>s2:
        #         last//=2+1
        #     while first<last:
        #         if nums2[first]*nums2[last]==s2:
        #             count+=1
        #             break
        #         elif nums2[first]*nums2[last]>s2:
        #             last-=1
        #         else:
        #             first+=1
        # for i in range(len(nums2)):
        #     s2=nums2[i]**2
        #     first,last=0,len(nums1)-1
        #     while nums1[last//2]>s2:
        #         last//=2+1
        #     while first<last:
        #         if nums1[first]*nums1[last]==s2:
        #             count+=1
        #             break
        #         elif nums1[first]*nums1[last]>s2:
        #             last-=1
        #         else:
        #             first+=1
        return count


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # brute force?
        nums1.sort()
        nums2.sort()
        
        # type 1
        memo1 = collections.defaultdict(set)
        memo2 = collections.defaultdict(set)
        for i in range(len(nums1)):
            memo1[nums1[i]].add(i)
        for i in range(len(nums2)):
            memo2[nums2[i]].add(i)
        
        cnt = 0
        for i in range(len(nums1)):
            sq = nums1[i]*nums1[i]
            for j in range(len(nums2)):
                if nums2[j] > sq: break
                if sq % nums2[j] != 0:
                    continue
                target = sq//nums2[j]
                if target in memo2:
                    cnt += len(memo2[target])
                    if j in memo2[target]:
                        cnt -= 1 # self
        for i in range(len(nums2)):
            sq = nums2[i]*nums2[i]
            for j in range(len(nums1)):
                if nums1[j] > sq: break
                if sq % nums1[j] != 0:
                    continue
                target = sq//nums1[j]
                if target in memo1:
                    cnt += len(memo1[target])
                    if j in memo1[target]:
                        cnt -= 1 # self
        return cnt // 2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        result = 0
        for i in range(len(nums1)):
            dic = collections.defaultdict(int)
            for j in range(len(nums2)):
                target = (nums1[i] ** 2) / nums2[j]
                if target in dic:
                    result += dic[target]
                dic[nums2[j]] += 1
        for i in range(len(nums2)):
            dic = collections.defaultdict(int)
            for j in range(len(nums1)):
                target = (nums2[i] ** 2) / nums1[j]
                if target in dic:
                    result += dic[target]
                dic[nums1[j]] += 1
        return result

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        counter1 = Counter(nums1)
        counter2 = Counter(nums2)

        ret = 0
        for k, v in counter1.items():
            for i in range(1, k):
                if i in counter2 and k*k/i in counter2:
                    ret += v * counter2[i] * counter2[k*k/i]
            if counter2[k] >= 2:
                ret += v * counter2[k]*(counter2[k]-1)/2

        for k, v in counter2.items():
            for i in range(1, k):
                if i in counter1 and k*k/i in counter1:
                    ret += v * counter1[i] * counter1[k*k/i]
            if counter1[k] >= 2:
                ret += v * counter1[k]*(counter1[k]-1)/2
        return int(ret)

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1_products = productCounts(nums1)
        nums2_products = productCounts(nums2)
        nums1_squares = squareCounts(nums1)
        nums2_squares = squareCounts(nums2)

        result = 0
        for square, count in nums1_squares.items():
            result += count * nums2_products[square]

        for square, count in nums2_squares.items():
            result += count * nums1_products[square]

        return result

def productCounts(arr):
    result = Counter()
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            result.update((arr[i] * arr[j],))
    return result

def squareCounts(arr):
    result = Counter()
    for num in arr:
        result.update((num ** 2,))
    return result

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1 = list(Counter(nums1).items())
        nums2 = list(Counter(nums2).items())
        def find(target, count1, arr):
            seen = Counter()
            ans = 0
            for a, count2 in arr:
                if target % a == 0:
                    if (b := target // a) != a:
                        ans += count1 * count2 * seen[b]
                    else:
                        ans += count1 * math.comb(count2, 2)
                seen[a] += count2
            return ans
            
        @lru_cache(None)
        def twoProduct1(target, count):
            return find(target, count, nums1)

        @lru_cache(None)
        def twoProduct2(target, count):
            return find(target, count, nums2)

        return sum(twoProduct2(a*a, c) for a, c in nums1) + sum(twoProduct1(a*a, c) for a, c in nums2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # counters
        nums1_squared = [i**2 for i in nums1]
        nums2_squared = [i**2 for i in nums2]
        
        c1 = collections.Counter(nums1)
        c2 = collections.Counter(nums2)
        
        res = 0
        for n1 in nums1:
            for target in nums2_squared:
                if target/n1 in c1: 
                    res += c1[target/n1]
                    if n1**2 == target: res -= 1
        
        for n2 in nums2:
            for target in nums1_squared:
                if target/n2 in c2:
                    res += c2[target/n2]
                    if n2**2 == target: res -= 1
        
        return res//2


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        from collections import Counter
        set1=Counter(nums1)
        set2=Counter(nums2)
        ret=0
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                temp=int(math.sqrt(nums1[i]*nums1[j]))
                if temp**2==nums1[i]*nums1[j] and temp in set2:
                    ret+=set2[temp]
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                temp=int(math.sqrt(nums2[i]*nums2[j]))
                if temp**2==nums2[i]*nums2[j] and temp in set1:
                    ret+=set1[temp]
        return ret

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def solve(n1s, n2s):
            answer = 0
            for num1 in n1s:
                m = collections.defaultdict(int)
                for num2 in n2s:
                    if num1**2 % num2 == 0:
                        answer += m[num1**2//num2]
                    m[num2] += 1
            return answer
        return solve(nums1, nums2)+solve(nums2,nums1)

from typing import List
import bisect
from math import comb


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        nums1.sort()
        nums2.sort()
        res += self.find(nums1, nums2)
        res += self.find(nums2, nums1)
        return res

    def find(self, n1, n2):
        res = 0
        for n in n1:
            left = 0
            right = len(n2) - 1
            while left < right:
                if n2[left] * n2[right] == n ** 2:
                    if n2[left] == n2[right]:
                        res += comb(right - left + 1, 2)
                        while left < right and n2[left] == n2[left + 1]:
                            left += 1
                        while left < right and n2[right] == n2[right - 1]:
                            right -= 1
                    else:
                        nl = 1
                        nr = 1
                        while left < right and n2[left] == n2[left + 1]:
                            nl += 1
                            left += 1
                        while left < right and n2[right] == n2[right - 1]:
                            nr += 1
                            right -= 1
                        res += nl * nr
                    left += 1
                    right -= 1

                elif n2[left] * n2[right] < n ** 2:
                    left += 1
                else:
                    right -= 1
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # all positive numbers
        
#         nums1.sort()
#         nums2.sort()
        
#         d1 = {}
#         d2 = {}
        
#         self.ret = 0
#         def helper(a, b):
#             # pick one from a and pick two from b, record products in d
#             if len(b) < 2:
#                 return
#             # print(a, b)
#             for n in a:
#                 # iterate through a
#                 # n ^ 2 = product of two numbers in b
#                 for i in range(len(b)-1):
#                     if n * n > b[i] * b[-1]:
#                         continue
#                     for j in range(i+1, len(b)):
#                         if n * n == b[i] * b[j]:
#                             # found pairs
#                             self.ret += 1
#                         elif n * n < b[i] * b[j]:
#                             break
                            
                            
#         helper(nums1, nums2)
#         helper(nums2, nums1)
                            
        # return self.ret
        
        
        
        
        def helper(target, nums):
            ret = 0
            target = target * target
            d = {}
            s = set()
            for n in nums:
                if n in d:
                    # there is a pair
                    s.add((min(n, target // n), max(n, target // n)))
                
                if target % n == 0:
                    # candidate
                    if target // n in d:
                        d[target // n] += 1
                    else:
                        d[target // n] = 1
            
            # print(target, nums, s, d)
            for a, b in s:
                if a == b:
                    ret += d[a] * (d[a]-1) // 2
                else:    
                    ret += d[a] * d[b]
            return ret
           
        ans = 0
        for n1 in nums1:
            ans += helper(n1, nums2)
        for n2 in nums2:
            ans += helper(n2, nums1)
                    
        return ans
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1, d2 = dict(), dict()

        for idx, n1 in enumerate(nums1):
            d1[idx] = dict()
            for elm in nums1[idx+1:]:
                try:
                    d1[idx][elm] += 1
                except KeyError:
                    d1[idx][elm] = 1


        for idx, n2 in enumerate(nums2):
            d2[idx] = dict()
            for elm in nums2[idx+1:]:
                try:
                    d2[idx][elm] += 1
                except KeyError:
                    d2[idx][elm] = 1
                    
        good = 0

        for n1 in nums1:
            for idx, n2 in enumerate(nums2):
                try:
                    good += d2[idx][n1**2/n2]
                except KeyError:
                    pass




        for n2 in nums2:
            for idx, n1 in enumerate(nums1):
                try:
                    good += d1[idx][n2**2/n1] 
                except KeyError:
                    pass
        
        return good
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1 = len(nums1)
        n2 = len(nums2)

        nn1 = []
        nn2 = []
        
        for j in range(n2):
            for k in range(j+1,n2):
                nn2.append(nums2[j]*nums2[k])
        for j in range(n1):
            for k in range(j+1,n1):
                nn1.append(nums1[j]*nums1[k])
        
        cnt = 0
        nnn1 = set(nums1)
        nnn2 = set(nums2)
        for i in nnn1:
            cnt+= nn2.count(i*i)*nums1.count(i)
        
        for i in nnn2:
            cnt+= nn1.count(i*i)*nums2.count(i)
        
        return cnt

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def count(num, nums):
            m = {}
            cnt = 0
            for n in nums:
                if num%n == 0:
                    if m.get(num/n) is not None:
                        cnt += m[num/n]
                if m.get(n) is None:
                    m[n] = 1
                else:
                    m[n] += 1
            return cnt

        res = 0
        for num in nums1:
            res += count(num*num, nums2)
        for num in nums2:
            res += count(num*num, nums1)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        def helper(l1, l2):
            nonlocal ans
            for e in l1:
                tar = e**2
                dp = Counter()
                for x in l2:
                    if tar%x==0:
                        ans += dp[tar//x]
                    dp[x] += 1
        helper(nums1, nums2)
        helper(nums2, nums1)
        return ans

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dic1 = defaultdict(list)
        dic2 = defaultdict(list)
        for idx, i in enumerate(nums1):
            dic1[i].append(idx)
        for idx, i in enumerate(nums2):
            dic2[i].append(idx)
        count = 0
        for i in nums1:
            sq = i * i
            for j in set(nums2):
                ano = sq / j
                # print(\"ano,\", ano, sq, j)
                if ano != int(ano): continue
                ano = int(ano)
                if ano in dic2:
                    inc = 0
                    if ano == j:
                        inc += int(len(dic2[ano]) * (len(dic2[ano])-1) / 2)
                    else:
                        inc += len(dic2[ano]) * len(dic2[j]) / 2
                    count += inc
                    # print(\"i is\", i, \" inc\", inc)
        for i in nums2:
            sq = i * i
            for j in set(nums1):
                ano = sq / j
                if ano != int(ano): continue
                ano = int(ano)
                if ano in dic1:
                    inc = 0
                    if ano == j:
                        inc += int(len(dic1[ano]) * (len(dic1[ano])-1) / 2)
                    else:
                        inc += len(dic1[ano]) * len(dic1[j]) / 2
                    # print(\"i is\", i, \" inc\", inc)
                    count += inc
        return int(count)

import math
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def isSquare(n):
            return math.sqrt(n) == int(math.sqrt(n))
        from collections import Counter
        hash1 = Counter(nums1)
        print(hash1)
        out = 0
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                k = nums2[i] * nums2[j]
                if isSquare(k):
                    if int(math.sqrt(k)) in hash1:
                        out += hash1[int(math.sqrt(k))]
        print(out)
        hash2 = Counter(nums2)
        
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                k = nums1[i] * nums1[j]
                if isSquare(k):
                    if int(math.sqrt(k)) in hash2:
                        out += hash2[int(math.sqrt(k))]
        print(out)
        return out

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1, d2 = dict(), dict()

        for idx, n1 in enumerate(nums1):
            d1[idx] = dict()
            for elm in nums1[idx+1:]:
                try:
                    d1[idx][elm] += 1
                except KeyError:
                    d1[idx][elm] = 1

        for idx, n2 in enumerate(nums2):
            d2[idx] = dict()
            for elm in nums2[idx+1:]:
                try:
                    d2[idx][elm] += 1
                except KeyError:
                    d2[idx][elm] = 1
                    
        good = 0

        for n1 in nums1:
            for idx, n2 in enumerate(nums2):
                try:
                    good += d2[idx][n1**2/n2]
                except KeyError:
                    pass




        for n2 in nums2:
            for idx, n1 in enumerate(nums1):
                try:
                    good += d1[idx][n2**2/n1] 
                except KeyError:
                    pass
        
        return good
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        # nums1.sort()
        # nums2.sort()
        for i in range(len(nums1)):
            hashmap = collections.defaultdict(int)
            for j in range(len(nums2)):
                if nums1[i] * nums1[i] / nums2[j] in hashmap:
                    ans += hashmap[nums1[i] * nums1[i] / nums2[j]]
                    # print(i,j, hashmap)
                hashmap[nums2[j]] += 1
                
        for i in range(len(nums2)):
            hashmap = collections.defaultdict(int)
            for j in range(len(nums1)):
                if nums2[i] * nums2[i] / nums1[j] in hashmap:
                    ans += hashmap[nums2[i] * nums2[i] / nums1[j]]
                    # print(i,j, hashmap)
                hashmap[nums1[j]] += 1
            
            # for j in range(len(nums2) - 1):
            #     k = j + 1
            #     while k < len(nums2):
            #         if nums1[i] * nums1[i] == nums2[j] * nums2[k]:
            #             ans += 1
            #             # print((i,j,k))
        #     #         k += 1
        # for i in range(len(nums2)):
        #     j, k = 0, len(nums1) - 1
        #     while j < k:
        #         if nums2[i] * nums2[i] == nums1[j] * nums1[k]:
        #             ans += 1
        #             j += 1
        #         elif nums2[i] * nums2[i] < nums1[j] * nums1[k]:
        #             k -= 1
        #         else:
        #             j += 1
        return ans


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        def helper(l1,l2):
            nonlocal ans
            c = Counter(l2)
            for x in l1:
                num = x*x
                c2 = c.copy()
                for i in range(len(l2)):
                    curr = l2[i]
                    c2[curr] -= 1
                    if c2[curr] == 0:
                        c2.pop(curr)
                    # print(num,curr,c2)
                    if num%curr == 0 and num//l2[i] in c2:
                        ans += c2[num//l2[i]]
                        
        helper(nums1,nums2)
        helper(nums2,nums1)
        return ans
        
                    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        ans = 0
        for n in nums1:
            d = {}
            for i,m in enumerate(nums2):
                if n**2/m in d:
                    ans+=d[n**2/m]
                if m in d:
                    d[m]+=1
                else:
                    d[m]=1
        for n in nums2:
            d = {}
            for i,m in enumerate(nums1):
                if n**2/m in d:
                    ans+=d[n**2/m]
                if m in d:
                    d[m]+=1
                else:
                    d[m]=1
        return ans
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        def ok(n, sorted_lst):
            i,j = 0, len(sorted_lst)-1
            ret = 0
            #print(n, sorted_lst)
            while 0<=i<j<len(sorted_lst):
                t = sorted_lst[i]*sorted_lst[j]
                if t>n:
                    j-=1
                    while i<j<len(sorted_lst)-1 and sorted_lst[j] == sorted_lst[j+1]:
                        j-=1
                elif t<n:
                    i+=1
                    while 0<i<j and sorted_lst[i]==sorted_lst[i-1] :
                        i+=1
                elif sorted_lst[i]==sorted_lst[j]: #reach center elements
                    #print(n, sorted_lst[i])
                    ret += (j-i+1)*(j-i)//2 
                    break
                else:
                    #print(n, i,j,sorted_lst[i],sorted_lst[j])
                    a,b=1,1
                    i+=1
                    while 0<i<j and sorted_lst[i] == sorted_lst[i-1]:
                        i+=1
                        a+=1
                    j-=1
                    #print(i,j,sorted_lst[j])
                    while i<=j<len(sorted_lst)-1 and sorted_lst[j] == sorted_lst[j+1]:
                        j-=1
                        b+=1
                    #print(a,b, a*b)
                    ret += a*b
                    
            return ret
        
        tot, cur = 0, 0
        for i, v in enumerate(nums1):
            if i==0 or v!=nums1[i-1]:
                cur = ok(v*v,nums2)
            tot += cur
        
        for i, v in enumerate(nums2):
            if i==0 or v!=nums2[i-1]:
                cur = ok(v*v,nums1)
            tot+=cur
        return tot

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1_cnt = collections.Counter(nums1)
        nums1_square_cnt = {x*x:nums1_cnt[x] for x in nums1_cnt}
        nums2_cnt = collections.Counter(nums2)
        nums2_square_cnt = {y*y:nums2_cnt[y] for y in nums2_cnt}

        def f(nums_a, cnt_a, cnt_b_squares):
            uniq_a_vals = list(cnt_a.keys())
            if len(uniq_a_vals) == 1:
                x = uniq_a_vals[0]
                if x * x in cnt_b_squares:
                    return (cnt_a[x] * (cnt_a[x] - 1) // 2) * cnt_b_squares[x*x]
            
            total = 0
            for i in range(len(nums_a)):
                for j in range(i + 1, len(nums_a)):
                    x, y = nums_a[i], nums_a[j]
                    if x * y in cnt_b_squares:
                        total +=  cnt_b_squares[x*y]
            return total
        
        return f(nums1, nums1_cnt, nums2_square_cnt) + f(nums2, nums2_cnt, nums1_square_cnt)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1_cnt = collections.Counter(nums1)
        nums1_square_cnt = {x*x:nums1_cnt[x] for x in nums1_cnt}
        nums2_cnt = collections.Counter(nums2)
        nums2_square_cnt = {y*y:nums2_cnt[y] for y in nums2_cnt}

        def f(nums_a, cnt_a, cnt_b_squares):
            if len(cnt_a) == 1:
                x = next(iter(cnt_a))
                if x * x in cnt_b_squares:
                    return (cnt_a[x] * (cnt_a[x] - 1) // 2) * cnt_b_squares[x*x]
            
            total = 0
            for i in range(len(nums_a)):
                for j in range(i + 1, len(nums_a)):
                    x, y = nums_a[i], nums_a[j]
                    if x * y in cnt_b_squares:
                        total +=  cnt_b_squares[x*y]
            return total
        
        return f(nums1, nums1_cnt, nums2_square_cnt) + f(nums2, nums2_cnt, nums1_square_cnt)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1_cnt = collections.Counter(nums1)
        nums1_square_cnt = {x*x:nums1_cnt[x] for x in nums1_cnt}
        nums2_cnt = collections.Counter(nums2)
        nums2_square_cnt = {y*y:nums2_cnt[y] for y in nums2_cnt}

        def f(nums_a, cnt_a, cnt_b_squares):
            if len(cnt_a) == 1:
                x = next(iter(cnt_a))
                if x * x in cnt_b_squares:
                    return (cnt_a[x] * (cnt_a[x] - 1) // 2) * cnt_b_squares[x*x]
            
            total = 0
            for i in range(len(nums_a)):
                for j in range(i + 1, len(nums_a)):
                    x, y = nums_a[i], nums_a[j]
                    if x * y in cnt_b_squares:
                        total += cnt_b_squares[x*y]
            return total
        
        return f(nums1, nums1_cnt, nums2_square_cnt) + f(nums2, nums2_cnt, nums1_square_cnt)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1 = collections.Counter(nums1)
        c2 = collections.Counter(nums2)
        
        res = 0
        for x in c1:
            for y in c2:
                if x == y:
                    res += (c1[x] * c2[y] * (c2[y] - 1))//2                  
                elif x**2 % y == 0 and y < x**2 // y:
                    res += c1[x]*c2[y]*c2[x**2 // y]                    
        
        c1, c2 = c2, c1
        for x in c1:
            for y in c2:
                if x == y:
                    res += (c1[x] * c2[y] * (c2[y] - 1))//2
                elif x**2 % y == 0 and y < x**2 // y:
                    res += c1[x]*c2[y]*c2[x**2 // y]
                    
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def f(u, v):
            v = Counter(float(i) for i in v)
            # print(f'u {u} v {v}')
            for x in u:
                w = x * x
                
                for y in v:
                    if y == x:
                        n = v[y]
                        # print(f'!! x {x} y {y} n {n}')
                        yield n * (n-1)
                        continue
                    z = w / y
                    if z in v:
                        # print(f'!! x {x} y {y} z{z} v[y] * v[z] {v[y] * v[z]}')
                        yield v[y] * v[z]
        
        # a = f(nums1, nums2)
        # b = f(nums2, nums1)
        # print(sum(a), sum(b))
        a = sum(f(nums1, nums2)) + sum(f(nums2, nums1))
        return a // 2

from functools import lru_cache
from collections import Counter


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(target, arr):
            seen = Counter()
            count = 0
            for a in arr:
                if target % a == 0:
                    count += seen[target // a]
                seen[a] += 1
            return count

        @lru_cache(None)
        def twoProduct1(target):
            return find(target, nums1)

        @lru_cache(None)
        def twoProduct2(target):
            return find(target, nums2)

        return sum(twoProduct2(a * a) for a in nums1) + sum(twoProduct1(a * a) for a in nums2)

from collections import Counter


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(target, arr):
            seen = Counter()
            count = 0
            for a in arr:
                if target % a == 0:
                    count += seen[target // a]
                seen[a] += 1
            return count

        def twoProduct(target, nums):
            if target in lut:
                return lut[target]
            lut[target] = find(target, nums)
            return lut[target]

        lut = Counter()
        ret1 = sum(twoProduct(a * a, nums2) for a in nums1)
        lut = Counter()
        ret2 = sum(twoProduct(a * a, nums1) for a in nums2)
        return ret1 + ret2

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count1 = Counter(nums1)
        count2 = Counter(nums2)
        return self.count_triplets(count1, count2) + self.count_triplets(count2, count1)
        
    def count_triplets(self, count1, count2):
        triplets = 0
        for n1, c1 in count1.items():
            for n2, c2 in count2.items():
                n3 = (n1 ** 2) / n2
                c3 = count2[n3]
                if n2 == n3:
                    triplets += c1 * c3 * (c3 - 1) / 2
                else:
                    triplets += (c1 * c2 * c3) / 2
                    
                # print(n1, n2, n3, triplets)
                
        return int(triplets)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(target, arr):
            seen = Counter()
            count = 0
            for a in arr:
                if target % a == 0:
                    count += seen[target // a]
                seen[a] += 1
            return count
            
        @lru_cache(None)
        def twoProduct1(target):
            return find(target, nums1)

        @lru_cache(None)
        def twoProduct2(target):
            return find(target, nums2)

        return sum(twoProduct2(a*a) for a in nums1) + sum(twoProduct1(a*a) for a in nums2)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sq1 = Counter([n**2 for n in nums1])
        sq2 = Counter([n**2 for n in nums2])
        triplets = self.count_triplets(sq1, nums2)
        triplets += self.count_triplets(sq2, nums1)
        return triplets
    
    def count_triplets(self, sqs: List[int], nums: List[int]) -> int:
        pairs = defaultdict(int)
        triplets = 0
        for n in nums:
            if n in pairs:
                triplets += pairs[n]
            for k in sqs:
                pairs[k/n] += sqs[k]
        return triplets

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
      num1Map = defaultdict(int ) 
      for i,n in enumerate(nums1):
        num1Map[n]+=1
        
      num2Map = defaultdict(int) 
      for i,n in enumerate(nums2):
        num2Map[n]+=1
        
      def count(nums,numsMap):
        out = 0
        same = 0
        for n1 in nums:
          sq = n1 * n1
          for n2,v in list(numsMap.items()):
            if sq/n2 == sq//n2:
              k =numsMap.get(sq//n2)
              if sq//n2 == n2 :
                if k > 1:
                  same+= math.factorial(k)// (math.factorial(k-2) * math.factorial(2)  )
              elif k:
                out+= k * v
        return same +out//2 
      
      out=0   
      out +=count(nums1,num2Map)     
      out +=count(nums2,num1Map)     
      return out 
      
      


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        def countTriplets(nums1, nums2):
            num2idx = defaultdict(list)
            for i, n in enumerate(nums2):
                num2idx[n].append(i)
            
            #print(num2idx)
            res = 0
            ct1 = Counter(nums1)
            for n in ct1:
                nsq = n**2
                for i, n1 in enumerate(nums2):
                    n2, mod2 = divmod(nsq, n1)
                    #print(n1, n2, n, mod2)
                    if mod2 == 0 and n2 in num2idx:
                        #print(n1, n2, nsq, len([x for x in num2idx[n2] if x > i]))
                        res += len([x for x in num2idx[n2] if x > i]) * ct1[n]
            return res
        
        return countTriplets(nums1, nums2) +  countTriplets(nums2, nums1)
                        
        


from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1 = Counter(nums1)
        c2 = Counter(nums2)
        ans = 0
        for x in nums1:
            sqr = x*x
            for y in c2.keys():
                if sqr%y == 0:
                    z = sqr//y
                    if y == z:
                        ans += c2[y] * (c2[y]-1)
                    else:
                        ans+= c2[y] * c2.get(z, 0)
        for x in nums2:
            sqr = x*x
            for y in c1.keys():
                if sqr%y == 0:
                    z = sqr//y
                    if y == z:
                        ans += c1[y] * (c1[y]-1)
                    else:
                        ans+= c1[y] * c1.get(z, 0)
        return ans//2

from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count1 = Counter(nums1)
        count2 = Counter(nums2)
        return self.count_triplets(count1, count2) + self.count_triplets(count2, count1)
        
    def count_triplets(self, count1, count2):
        triplets = 0
        for n1, c1 in count1.items():
            for n2, c2 in count2.items():
                n3 = (n1 ** 2) / n2
                c3 = count2[n3]
                if n2 == n3:
                    triplets += c1 * c3 * (c3 - 1) / 2
                else:
                    triplets += (c1 * c2 * c3) / 2
                                    
        return int(triplets)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        count=self.counttrip(nums1,nums2)
        
        count+=self.counttrip(nums2,nums1)
        return int(count)
        
    def counttrip(self,nums1,nums2):
        seen=defaultdict(int)
        count=0
        for i in nums1:
            p=i*i
            if(p in seen):
                count+=seen[p]
                continue
            
            localcount=0
            left=0
            right = len(nums2)-1
            
            while(left<right):
                if(nums2[left]>p):
                    break
                if(nums2[left]*nums2[right]==p):
                    if(nums2[left]==nums2[right]):
                        n=right-left+1
                        localcount+=n*(n-1)/2
                        break
                    localcount+=1
                    nleft=left+1
                    while(nums2[nleft]==nums2[nleft-1] and nleft<right):
                        nleft+=1
                        localcount+=1
                    right-=1
                    left=0
                elif(nums2[left]*nums2[right]>p):
                    
                    right-=1
                elif(nums2[left]*nums2[right]<p):
                    left+=1
            count+=localcount       
            seen[p]=localcount
                    
        return count


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def cal(arr1, arr2):
            countMap = {}
            m = defaultdict(list)
            count = 0
            for i in range(len(arr2)): m[arr2[i]].append(i)
            for e in arr1:
                if e in countMap: 
                    count += countMap[e]
                    continue
                c = 0
                for i in range(len(arr2)):
                    if not e*e%arr2[i]:
                        d = e*e//arr2[i]
                        c += sum([0]+[1 for idx in m[d] if idx != i])
                countMap[e] = c
                count += c
                        
            return count//2
        return cal(nums1, nums2) + cal(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def count(arr1, arr2):
            res = 0
            dic = collections.Counter(arr1)
            for a in dic:
                counter = collections.Counter()
                for b in arr2:
                    c = a * a / b
                    if c in counter:
                        res += counter[c] * dic[a]
                    counter[b] += 1
            return res
        res = count(nums1, nums2)
        res += count(nums2, nums1)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1 = dict()
        lookup2 = dict()
        for num1 in nums1:
            lookup1[num1] = lookup1.get(num1, 0) + 1
        for num2 in nums2:
            lookup2[num2] = lookup2.get(num2, 0) + 1
        mem = dict()
        
        
        ans = 0
        ans1 = 0
        ans2 = 0
        for idx1 in range(len(nums1)):
            num1 = nums1[idx1]
            if num1 in mem:
                ans1 += mem[num1][0]
                ans2 += mem[num1][1]
                continue
            lookup1[num1] -= 1
            ans1_tmp = 0
            ans2_tmp = 0
            for idx2 in range(len(nums2)):
                num2 = nums2[idx2]
                lookup2[num2] -= 1
                if lookup2.get( (num1**2 / num2), 0 ) > 0:
                    #print(num1, num2, lookup2)
                    ans1_tmp += lookup2[(num1**2 / num2)]
                lookup2[num2] += 1
                
                
                if lookup1.get( (num2**2 / num1), 0 ) > 0:
                    ans2_tmp += lookup1[(num2**2 / num1)]
            mem[nums1[idx1]] = (ans1_tmp, ans2_tmp)
            ans1 += ans1_tmp
            ans2 += ans2_tmp
                    
            lookup1[num1] += 1
            
        return ans1 // 2 + ans2 // 2

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def find(target, arr):
            seen = Counter()
            count = 0
            for a in arr:
                if target % a == 0:
                    count += seen[target // a]
                seen[a] += 1
            return count
            
        @lru_cache(None)
        def twoProduct1(target):
            return find(target, nums1)

        @lru_cache(None)
        def twoProduct2(target):
            return find(target, nums2)

        return sum(twoProduct2(a*a) for a in nums1) + sum(twoProduct1(a*a) for a in nums2)
    
    def numTriplets2(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = collections.defaultdict(int)
        d2 = collections.defaultdict(int)
        for i in nums1:
            d1[i * i] += 1
        for i in nums2:
            d2[i * i] += 1
        res = 0
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                p = nums1[i] * nums1[j]
                if p in d2:
                    res += d2[p]
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                p = nums2[i] * nums2[j]
                if p in d1:
                    res += d1[p]
        return res
    
    def numTriplets3(self, A1: List[int], A2: List[int]) -> int:
        A1.sort()
        A2.sort()
        C1,C2=collections.Counter(A1),collections.Counter(A2)
        # print(A1,A2,C1,C2)
        res=0
        N1,N2=len(A1),len(A2)
        seen=set()
        for i,x in enumerate(A1):
            for j,y1 in enumerate(A2):
                if x*x<y1:break
                # if y1 in seen:continue
                y2=x*x//y1
                if x*x%y1==0 and y2 in C2:
                    c=C2[y2]
                    # print(x,y1,c)
                    if x==y1:res+=comb(c,2)# if c>1 else 0
                    else:res+=c*C2[y1]
                    seen|={y1,y2}
                    break
        # print(res)
        seen=set()
        for x in A2:
            for y1 in A1:
                if x*x<y1:break
                # if y1 in seen:continue
                y2=x*x//y1
                if x*x%y1==0 and y2 in C1:
                    c=C1[y2]
                    # print('-',x,y1,c)
                    if x==y1:res+=comb(c,2)# if c>1 else 0
                    else:res+=c*C1[y1]
                    seen|={y1,y2}
                    break
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        prod_nums1 = collections.Counter([v1 * v2 for v1,v2 in itertools.combinations(nums1,2)])
        prod_nums2 = collections.Counter([v1 * v2 for v1,v2 in itertools.combinations(nums2,2)])
        
        return sum([prod_nums2[n1**2] for n1 in nums1]) + sum([prod_nums1[n2**2] for n2 in nums2])
        
        
        


from collections import defaultdict

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        nums1.sort()
        nums2.sort()
        
        def search(array1, array2):
            result = 0
            hashtable = defaultdict(int)
            
            for i in array2:
                    hashtable[i] += 1
            
            for a in array1:
                squared = a ** 2
                
                met = []
                for i in list(hashtable.keys()):
                    if i not in met:
                        if squared % i == 0:
                            complement = squared // i
                            if complement != i:
                                result += hashtable[i] * hashtable[complement]
                                met.append(complement)
                                # print(hashtable[i] * hashtable[complement], i, complement)
                                # hashtable[i] = 0
                                # hashtable[complement] = 0
                            else:
                                met.append(i)
                                result += sum([j for j in range(hashtable[i])])
                                # print(hashtable[i], i, complement)
                                # hashtable[i] = 0
                        
            
            return result
                        
        count += search(nums1, nums2)
        count += search(nums2, nums1)
        
        return count
                            
                        
                        


from collections import Counter
from itertools import combinations

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        c1 = Counter([x*y for x, y in combinations(nums1, 2)])
        c2 = Counter([x*y for x, y in combinations(nums2, 2)])
        return sum([c1[x*x] for x in nums2]) + sum([c2[x*x] for x in nums1])


from collections import Counter
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1_cnts, n2_cnts = Counter(nums1), Counter(nums2)
        
        good = 0
        n2_cnts_copy = n2_cnts.copy()
        for n2j in nums2:
            n2_cnts_copy[n2j] -= 1
            for n1, cnt in list(n1_cnts.items()):
                good += cnt*n2_cnts_copy[n1**2/n2j]
                
        for n1j in nums1:
            n1_cnts[n1j] -= 1
            for n2, cnt in list(n2_cnts.items()):
                good += cnt*n1_cnts[n2**2/n1j]
                
        return good
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums, lookup):
            # print('nums = {0}, lookup = {1}'.format(nums, lookup))
            res = 0
            for maxNum in nums:
                prod = maxNum * maxNum
                # print('maxNum = {0}, prod = {1}'.format(maxNum, prod))
                for n in lookup.keys():
                    if n <= maxNum and not prod % n:
                        m = prod // n
                        # print('m = {0}, n = {1}'.format(m, n))
                        
                        res += (lookup[n] * (lookup[n] - 1)) // 2 if m == n else lookup[m] * lookup[n]
            return res
        return helper(nums1, collections.Counter(nums2)) + helper(nums2, collections.Counter(nums1))
    
        
    # slown
    def numTriplets1(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1, lookup2 = collections.defaultdict(int), collections.defaultdict(int)
        for n in nums1:
            lookup1[n] += 1
        for n in nums2:
            lookup2[n] += 1
        res = 0
        for k in [0, 1]:
            nums = nums1 if not k else nums2
            lookup = lookup1 if k else lookup2
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    prod = nums[i] * nums[j]
                    k = int(math.sqrt(prod))
                    if k * k == prod and k in lookup:
                        res += lookup[k]
        return res

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        n1_cnts, n2_cnts = defaultdict(int), defaultdict(int)
        
        for n1 in nums1:
            n1_cnts[n1] += 1
        
        for n2 in nums2:
            n2_cnts[n2] += 1
        
        good = 0
        n2_cnts_copy = n2_cnts.copy()
        for n2j in nums2:
            n2_cnts_copy[n2j] -= 1
            for n1, cnt in list(n1_cnts.items()):
                good += cnt*n2_cnts_copy[n1**2/n2j]
                
        for n1j in nums1:
            n1_cnts[n1j] -= 1
            for n2, cnt in list(n2_cnts.items()):
                good += cnt*n1_cnts[n2**2/n1j]
                
        return good
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = collections.defaultdict(int)
        d2 = collections.defaultdict(int)
        for i in nums1:
            d1[i * i] += 1
        for i in nums2:
            d2[i * i] += 1
        res = 0
        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                p = nums1[i] * nums1[j]
                if p in d2:
                    res += d2[p]
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                p = nums2[i] * nums2[j]
                if p in d1:
                    res += d1[p]
        return res
#         pow_nums1 = [ x**2 for x in nums1 ]
#         pow_nums2 = [ x**2 for x in nums2 ]
#         count = 0

#         # type 1
#         for num_index in range(len(nums2) - 1): # exclude the last one
#             current = nums2[num_index]
#             rests = nums2[num_index + 1:]
#             for rest in rests:
#                 product = current * rest
#                 count += pow_nums1.count(product)
#         # type 2
#         for num_index in range(len(nums1) - 1): # exclude the last one
#             current = nums1[num_index]
#             rests = nums1[num_index + 1:]
#             for rest in rests:
#                 product = current * rest
#                 count += pow_nums2.count(product)
                    

#         return count
    


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        m1=collections.defaultdict(lambda: 0)
        m2=collections.defaultdict(lambda: 0)
        
        for i in range(len(nums1)):
            m1[nums1[i]**2]+=1
        for i in range(len(nums2)):
            m2[nums2[i]**2]+=1
        
#         print(m1)
#         print(m2)
        ans=0
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                # if(i==j):
                #     continue
                ans+=m2[nums1[i]*nums1[j]]
                
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                # if(i==j):
                #     continue
                ans+=m1[nums2[i]*nums2[j]]
        
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def prod_finder(num_list1, num_list2):
            prod_map = {}
            for n in num_list1:
                prod_map[n*n] = 0
            for n in num_list1:
                prod_map[n*n] += 1
                
            count = 0
            
            for i in range(0, len(num_list2)):
                for j in range(i+1, len(num_list2)):
                    p = num_list2[i] * num_list2[j]
                    if p in prod_map:
                        count += prod_map[p]
            return count
        return prod_finder(nums1, nums2) + prod_finder(nums2, nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        # TC : O(n**2), where n = max(#nums1, #nums2)
        nums1_sq_dct = collections.defaultdict(int)
        nums2_sq_dct = collections.defaultdict(int)
        
        res = 0
        
        for x in nums1:
            nums1_sq_dct[x**2] += 1
        for y in nums2:
            nums2_sq_dct[y**2] += 1
            
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)) :
                res += nums2_sq_dct[nums1[i]*nums1[j]]
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)) :
                res += nums1_sq_dct[nums2[i]*nums2[j]]
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1,d2 = {}, {}
        for v in nums1:
            d1[v*v] = d1.get(v*v,0) + 1
        for v in nums2:
            d2[v*v] = d2.get(v*v,0) + 1
        res = 0
        for i,v in enumerate(nums1):
            for j in range(i+1, len(nums1)):
                res += d2.get(v*nums1[j], 0)
        for i,v in enumerate(nums2):
            for j in range(i+1, len(nums2)):
                res += d1.get(v*nums2[j], 0)
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        seta={}
        setb={}
        for i in nums1:
            if i*i in seta:
                seta[i*i]+=1
            else:
                seta[i*i]=1
        for i in nums2:
            if i*i in setb:
                setb[i*i]+=1
            else:
                setb[i*i]=1
        ans=0
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                if nums1[i]*nums1[j] in setb:
                    ans+=setb[nums1[i]*nums1[j]]
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                if nums2[i]*nums2[j] in seta:
                    ans+=seta[nums2[i]*nums2[j]]
        return ans

class Solution:
    # https://leetcode.com/submissions/detail/404293310/
    # fast
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def helper(nums, lookup):
            res = 0
            for maxNum in nums:
                prod = maxNum * maxNum
                for n in lookup.keys():
                    if n <= maxNum and not prod % n:
                        m = prod // n
                        # m ==n, combination.
                        res += (lookup[n] * (lookup[n] - 1)) // 2 if m == n else lookup[m] * lookup[n]
            return res
        return helper(nums1, collections.Counter(nums2)) + helper(nums2, collections.Counter(nums1))
    
        
    # slow
    def numTriplets1(self, nums1: List[int], nums2: List[int]) -> int:
        lookup1, lookup2 = collections.defaultdict(int), collections.defaultdict(int)
        lookup1, lookup2 = collections.Counter(nums1), collections.Counter(nums2)
        res = 0
        for k in [0, 1]:
            nums = nums1 if not k else nums2
            lookup = lookup1 if k else lookup2
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    prod = nums[i] * nums[j]
                    k = int(math.sqrt(prod))
                    if k * k == prod and k in lookup:
                        res += lookup[k]
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = defaultdict(int)
        d2 = defaultdict(int)
        ans = 0
        
        for i in nums1:
            d1[i*i] += 1
        for i in nums2:
            d2[i*i] += 1
        
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                ans += d2[nums1[i]*nums1[j]]
        
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                ans += d1[nums2[i]*nums2[j]]
        
        
        return ans

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        count = 0
        d1 = {}
        d2 = {}
        
        # comparing nums1^2 with nums2 product
        for i in nums1:
            if i**2 not in d1:
                d1[i**2] = 1
            else:
                d1[i**2]+= 1
        
        for j in range(len(nums2)):
            for k in range(j+1,len(nums2)):
                prod = nums2[j]*nums2[k]
                if prod in d1:
                    count+=d1[prod]
                    
        # comparing nums2^2 with nums1 product
        for i in nums2:
            if i**2 not in d2:
                d2[i**2] = 1
            else:
                d2[i**2]+= 1
        
        for j in range(len(nums1)):
            for k in range(j+1,len(nums1)):
                prod = nums1[j]*nums1[k]
                if prod in d2:
                    count+=d2[prod]
    
        
        return count

from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        count = 0
        d1 = defaultdict(int)
        d2 = defaultdict(int)
        
        for n in nums1:
            d1[n*n] += 1
        
        for n in nums2:
            d2[n*n] += 1
            
        count = 0
        for i in range(0, len(nums1)-1):
            for j in range(i+1, len(nums1)):
                count += d2[nums1[i]*nums1[j]]
                    
        for i in range(0, len(nums2)-1):
            for j in range(i+1, len(nums2)):
                count += d1[nums2[i]*nums2[j]]
                    
        return count
        
        
        


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sq1 = collections.Counter([nums1[i] * nums1[j] for i in range(len(nums1)) for j in range(i)])
        sq2 = collections.Counter([nums2[i] * nums2[j] for i in range(len(nums2)) for j in range(i)])
        return sum(sq1[n**2] for n in nums2) + sum(sq2[n**2] for n in nums1)

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        sqr_nums1 = defaultdict(int)
        sqr_nums2 = defaultdict(int)
        res = 0
        for x in nums1:
            sqr_nums1[x*x] += 1
        for x in nums2:
            sqr_nums2[x*x] += 1
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                res += sqr_nums2[nums1[i]*nums1[j]]
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                res += sqr_nums1[nums2[i]*nums2[j]]
        return res
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        hashmap1= {}
        hashmap2= {}
        count =0
        
        for i in range(len(nums1)):
            if nums1[i]*nums1[i] not in hashmap1:
                hashmap1[nums1[i]*nums1[i]] =1
            else:
                hashmap1[nums1[i]*nums1[i]] +=1
                
           
        for j in range(len(nums2)):
            if nums2[j]*nums2[j] not in hashmap2:
                hashmap2[nums2[j]*nums2[j]]=1
            else:
                hashmap2[nums2[j]*nums2[j]]+=1
                
        for i in range(len(nums1)):
            for j in range(i+1,len(nums1)):
                if nums1[i]*nums1[j] in hashmap2:
                    count+=hashmap2[nums1[i]*nums1[j]]
                    
                
                
        for i in range(len(nums2)):
            for j in range(i+1,len(nums2)):
                if nums2[i]*nums2[j] in hashmap1:
                    count+=hashmap1[nums2[i]*nums2[j]]
        
        
        return count


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        '''
        primes = []
        available = [True for _ in range(100000)]
        available[0] = False
        available[1] = False
        k = 0
        
        while True:
            while k < len(available) and available[k] == False:
                k += 1
            if k == len(available):
                break
            primes.append(k)
            n = 1
            while n * k < len(available):
                available[n * k] = 0
                n += 1
            
        def factorize(x):
            result = collections.Counter()
            if x == 1:
                return result
            for p in primes:
                if x % p == 0:
                    result[p] += 1
                    return result + factorize(x // p)
                
        print(factorize(7 * 13 * 5))
        
        fac1 = [factorize(n) for n in nums1]
        fac2 = [factorize(n) for n in nums2]
        '''
        
        prod1 = collections.defaultdict(int)
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                prod1[nums1[i] * nums1[j]] += 1
        
        prod2 = collections.defaultdict(int)
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                prod2[nums2[i] * nums2[j]] += 1
                
        count = 0
        for n in nums1:
            count += prod2[n * n]
                
        for n in nums2:
            count += prod1[n * n]
                
        return count
                
        
        
        
                
                


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dic1, dic2 = collections.defaultdict(int), collections.defaultdict(int)
        
        for num in nums1:
            dic1[num**2] += 1
        for num in nums2:
            dic2[num**2] += 1
            
        res = 0
        for i in range(len(nums1)):
            for j in range(i+1, len(nums1)):
                res += dic2[nums1[i] * nums1[j]]
        
        for i in range(len(nums2)):
            for j in range(i+1, len(nums2)):
                res += dic1[nums2[i] * nums2[j]]
        
        return res

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        d1 = collections.defaultdict(int)
        d2 = collections.defaultdict(int)
        for i in nums1:
            d1[i * i] += 1
        for i in nums2:
            d2[i * i] += 1
        
        ans = 0
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                x = nums1[i] * nums1[j]
                ans += d2[x]
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                x = nums2[i] * nums2[j]
                ans += d1[x]
        return ans 
                               
                    
        
            


import collections
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        if len(nums1)<=1 and len(nums2)<=1:
            return 0
        numTri = 0
        nums1Sq = [num**2 for num in nums1]
        nums2Sq = [num**2 for num in nums2]
        nums1Mul = collections.Counter([nums1[i]*nums1[j] for i in range(len(nums1)) for j in range(i+1,len(nums1))])
        nums2Mul = collections.Counter([nums2[i]*nums2[j] for i in range(len(nums2)) for j in range(i+1,len(nums2))])
        for num in nums1Sq:
            if num in nums2Mul:
                numTri += nums2Mul[num] 
        for num in nums2Sq:
            if num in nums1Mul:
                numTri += nums1Mul[num] 
        return numTri

from collections import Counter


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        counter1 = Counter(nums1)
        counter2 = Counter(nums2)

        ret = 0
        for k1, v1 in counter1.items():
            for k2, v2 in counter2.items():
                if k1*k1/k2 in counter2:
                    if k2 == k1:
                        ret += v1*v2*(v2-1)
                    else:
                        ret += v1*v2*counter2[k1*k1/k2]

        for k2, v2 in counter2.items():
            for k1, v1 in counter1.items():
                if k2*k2/k1 in counter1:
                    if k2 == k1:
                        ret += v2*v1*(v1-1)
                    else:
                        ret += v1*v2*counter1[k2*k2/k1]
                        
        return int(ret/2)

from collections import defaultdict

class Solution:
  def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
    n1 = len(nums1)
    n2 = len(nums2)
    n1_squares = defaultdict(int)
    n2_squares = defaultdict(int)
    for num1 in nums1:
      n1_squares[num1*num1] += 1
      pass
    for num2 in nums2:
      n2_squares[num2*num2] += 1
      pass
    triplets = 0
    for i in range(n1-1):
      for j in range(i+1,n1):
        sq = nums1[i]*nums1[j]
        triplets += n2_squares[sq]
    for i in range(n2-1):
      for j in range(i+1,n2):
        sq = nums2[i]*nums2[j]
        triplets += n1_squares[sq]
    return triplets

from collections import defaultdict


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        cnt1, cnt2 = defaultdict(int), defaultdict(int)
        for i in range(len(nums1)):
            for j in range(i + 1, len(nums1)):
                cnt1[nums1[i] * nums1[j]] += 1
        for i in range(len(nums2)):
            for j in range(i + 1, len(nums2)):
                cnt2[nums2[i] * nums2[j]] += 1
        ans = 0
        for i in nums1: ans += cnt2[i * i]
        for i in nums2: ans += cnt1[i * i]
        return ans

class Solution:
    
    def work(self, nums1, nums2):
        res =0
        dic ={}
        for num in nums1:
            if num*num in dic:
                dic[num*num] +=1
            else:
                dic[num*num] =1
        
        n =len(nums2)
        for i in range(n):
            for j in range(i+1, n):
                if nums2[i] * nums2[j] in dic:
                    res += dic[nums2[i] * nums2[j]]
        return res
    
        
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        return self.work(nums1, nums2) + self.work(nums2, nums1);


class Solution:
    def numTriplets(self, a1: List[int], a2: List[int]) -> int:
        m1 = Counter([x**2 for x in a1])
        m2 = Counter([x**2 for x in a2])
        ans = 0
        n1, n2 = len(a1), len(a2)
        for i in range(n1-1):
            for j in range(i+1, n1):
                k = a1[i] * a1[j]
                if k in m2: ans += m2[k]
        for i in range(n2-1):
            for j in range(i+1, n2):
                k = a2[i] * a2[j]
                if k in m1: ans += m1[k]
        return ans

from typing import List
from collections import Counter

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        A = Counter([nums1[i]**2 for i in range(len(nums1))])
        B = Counter([nums2[i]**2 for i in range(len(nums2))])
        cnt = 0
        for j in range(len(nums2)):
            for k in range(j + 1, len(nums2)):
                cnt += A.get(nums2[j]*nums2[k], 0)
        for j in range(len(nums1)):
            for k in range(j + 1, len(nums1)):
                cnt += B.get(nums1[j]*nums1[k], 0)
        return cnt


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        
        d = {}
        ct = 0
        M = len(nums1)
        N = len(nums2)
        
        for i in range(M):
            if(nums1[i]*nums1[i] in d):
                d[nums1[i]*nums1[i]] += 1
            else:
                d[nums1[i]*nums1[i]] = 1
        
        for i in range(N):
            for j in range(i+1,N):
                if(nums2[i]*nums2[j] in d):
                    ct += d[nums2[i]*nums2[j]]
        d = {}
        for i in range(N):
            if(nums2[i]*nums2[i] in d):
                d[nums2[i]*nums2[i]] += 1
            else:
                d[nums2[i]*nums2[i]] = 1
        
        for i in range(M):
            for j in range(i+1,M):
                if(nums1[i]*nums1[j] in d):
                    ct += d[nums1[i]*nums1[j]]
        return ct

class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        res = 0
        d1 = collections.defaultdict(int)
        d2 = collections.defaultdict(int)
        
        for v in nums1:
            d1[v * v] += 1
        for v in nums2:
            d2[v * v] += 1
            
        for i in range(len(nums2) - 1):
            for j in range(i + 1, len(nums2)):
                if  nums2[i] * nums2[j] in d1:
                    res += d1[nums2[i] * nums2[j]]

        for i in range(len(nums1) - 1):
            for j in range(i + 1, len(nums1)):
                if nums1[i] * nums1[j] in d2:
                    res += d2[nums1[i] * nums1[j]]
        return res


from collections import defaultdict
class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        def get_sq_cnt(nums):
            cnt = defaultdict(int)
            n = len(nums)
            for i in range(n):
                for j in range(i+1, n):
                    cnt[nums[i]*nums[j]] +=1
            return cnt
        
        cnt1, cnt2 = get_sq_cnt(nums1), get_sq_cnt(nums2)
        res = 0
        for num1 in nums1:
            res += cnt2[num1*num1]
        for num2 in nums2:
            res += cnt1[num2*num2]
        
        return res


class Solution:
    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
        dict1 = Counter([x**2 for x in nums1])
        dict2 = Counter([x**2 for x in nums2])
        
        count=0
        for i in range(len(nums2)-1):
            for j in range(i+1,len(nums2)):
                count += dict1[nums2[i]*nums2[j]]
        for i in range(len(nums1)-1):
            for j in range(i+1,len(nums1)):
                count += dict2[nums1[i]*nums1[j]]
        
        return count

class Solution:
    def numTriplets(self, f: List[int], s: List[int]) -> int:
        from collections import defaultdict
        
        
        def helper(nums1, nums2):
            d = defaultdict(int)
            ans = 0    

            for i in range(len(nums1)):
                for j in range(i+1, len(nums1)):
                    d[nums1[i]* nums1[j]]+= 1

            for num in nums2:
                ans += d[num**2]
            return ans
                
        return helper(f,s )+ helper(s,f)