import sys

INF = float('inf')

def compute_min_cost(A, B, C, X, Y, Z):
    patterns = []

    # Pattern 1: A > C > B'
    def pattern1():
        min_cost = INF
        min_b = max(0, B - (C - 1))
        max_b = B - 1
        if min_b > max_b:
            return INF
        
        candidates = [min_b, max_b]
        for delta in [-1, 0, 1]:
            c_b = B - (A - 2) + delta
            if c_b >= min_b and c_b <= max_b:
                candidates.append(c_b)
        candidates = list(set(candidates))
        
        for b in candidates:
            if b < min_b or b > max_b:
                continue
            B_prime = B - b
            if B_prime < 1:
                continue
            C_prime = B_prime + 1
            c = C - C_prime
            if c < 0 or (C - c) < 1:
                continue
            required_A_prime = C_prime + 1
            if required_A_prime < 1:
                continue
            a = max(0, A - required_A_prime)
            A_prime = A - a
            if A_prime < 1:
                continue
            if A_prime > C_prime and C_prime > B_prime and (A_prime != C_prime) and (C_prime != B_prime) and (A_prime != B_prime):
                cost = a * X + b * Y + c * Z
                if cost < min_cost:
                    min_cost = cost
        return min_cost

    # Pattern 2: C > A > B'
    def pattern2():
        min_cost = INF
        min_b = max(0, B - (A - 1))
        max_b = B - 1
        if min_b > max_b:
            return INF
        
        candidates = [min_b, max_b]
        for delta in [-1, 0, 1]:
            c_b = B - (C - 2) + delta
            if c_b >= min_b and c_b <= max_b:
                candidates.append(c_b)
        candidates = list(set(candidates))
        
        for b in candidates:
            if b < min_b or b > max_b:
                continue
            B_prime = B - b
            if B_prime < 1:
                continue
            A_prime = B_prime + 1
            a = A - A_prime
            if a < 0:
                continue
            required_C_prime = A_prime + 1
            if required_C_prime < 1:
                continue
            c = C - required_C_prime
            if c < 0 or (C - c) < 1:
                continue
            C_prime = required_C_prime
            if C_prime > A_prime and A_prime > B_prime and (C_prime != A_prime) and (A_prime != B_prime) and (C_prime != B_prime):
                cost = a * X + b * Y + c * Z
                if cost < min_cost:
                    min_cost = cost
        return min_cost

    # Pattern 3: B > A > C'
    def pattern3():
        min_cost = INF
        min_c = max(0, C - (A - 1))
        max_c = C - 1
        if min_c > max_c:
            return INF
        
        candidates = [min_c, max_c]
        for delta in [-1, 0, 1]:
            c_c = C - (B - 2) + delta
            if c_c >= min_c and c_c <= max_c:
                candidates.append(c_c)
        candidates = list(set(candidates))
        
        for c in candidates:
            if c < min_c or c > max_c:
                continue
            C_prime = C - c
            if C_prime < 1:
                continue
            A_prime = C_prime + 1
            a = A - A_prime
            if a < 0:
                continue
            required_B_prime = A_prime + 1
            if required_B_prime < 1:
                continue
            b = B - required_B_prime
            if b < 0 or (B - b) < 1:
                continue
            B_prime = required_B_prime
            if B_prime > A_prime and A_prime > C_prime and (B_prime != A_prime) and (A_prime != C_prime) and (B_prime != C_prime):
                cost = a * X + b * Y + c * Z
                if cost < min_cost:
                    min_cost = cost
        return min_cost

    # Pattern 4: B > C > A'
    def pattern4():
        min_cost = INF
        min_a = max(0, A - (C - 1))
        max_a = A - 1
        if min_a > max_a:
            return INF
        
        candidates = [min_a, max_a]
        for delta in [-1, 0, 1]:
            c_a = A - (B - 2) + delta
            if c_a >= min_a and c_a <= max_a:
                candidates.append(c_a)
        candidates = list(set(candidates))
        
        for a in candidates:
            if a < min_a or a > max_a:
                continue
            A_prime = A - a
            if A_prime < 1:
                continue
            C_prime = A_prime + 1
            c = C - C_prime
            if c < 0 or (C - c) < 1:
                continue
            required_B_prime = C_prime + 1
            if required_B_prime < 1:
                continue
            b = B - required_B_prime
            if b < 0 or (B - b) < 1:
                continue
            B_prime = required_B_prime
            if B_prime > C_prime and C_prime > A_prime and (B_prime != C_prime) and (C_prime != A_prime) and (B_prime != A_prime):
                cost = a * X + b * Y + c * Z
                if cost < min_cost:
                    min_cost = cost
        return min_cost

    cost1 = pattern1()
    cost2 = pattern2()
    cost3 = pattern3()
    cost4 = pattern4()
    
    # Check other patterns like C > B > A and others if needed but according to Kadomatsu's second condition, only the four cases are possible
    min_total = min(cost1, cost2, cost3, cost4)
    
    return min_total if min_total != INF else -1

def main():
    input = sys.stdin.read().split()
    idx = 0
    T = int(input[idx])
    idx +=1
    for _ in range(T):
        A = int(input[idx])
        B = int(input[idx+1])
        C = int(input[idx+2])
        X = int(input[idx+3])
        Y = int(input[idx+4])
        Z = int(input[idx+5])
        idx +=6
        res = compute_min_cost(A, B, C, X, Y, Z)
        print(res if res != INF else -1)

if __name__ == "__main__":
    main()