#include <assert.h>
#include <stdio.h>
#include <algorithm>

using namespace std;

#define INF 1000000000

int X[4], A, B, C;

// Minimize: C * u +
//  A * (X[0] + X[1] + X[2] - 3 * u - 2 * min{X[2] - u, X[0] + X[1] - 2 * u}) +
//  B * min{X[2] - u, X[0] + X[1] - 4 * u}

int SolveCase1() {
	// X[2] - u <= X[0] + X[1] - 2 * u <=> u <= X[0] + X[1] - X[2]
	int umax = X[0] + X[1] - X[2];
	assert(umax <= (X[0] + X[1] + X[2]) / 3);
	if (umax < 0) return INF;
	if (umax > X[0]) umax = X[0];
	// C * u + A * (X[0] + X[1] + X[2] - 3 * u - 2 * (X[2] - u)) + B * (X[2] - u) =
	// A * (X[0] + X[1] - X[2]) + B * X[2] + u * (C - A - B)
	const int base = A * (X[0] + X[1] - X[2]) + B * X[2];
	const int dif = C - A - B;
	fprintf(stderr, "C1: base=%d dif=%d umax=%d\n", base, dif, umax);
	if (dif < 0) return base + dif * umax;
	return base;
}

int SolveCase2() {
	// X[0] + X[1] - 2 * u < X[2] - u <=> u > X[0] + X[1] - X[2]
	const int umin = max(X[0] + X[1] - X[2] + 1, 0);
	const int umax = X[0];
	if (umin > umax) return INF;
	// C * u + A * (X[0] + X[1] + X[2] - 3 * u - 2 * (X[0] + X[1] - 2 * u)) + B * (X[0] + X[1] - 2 * u) =
	// B * (X[0] + X[1]) + A * (X[2] - X[0] - X[1]) + u * (C + A - 2 * B)
	const int base = B * (X[0] + X[1]) + A * (X[2] - X[0] - X[1]);
	const int dif = C + A - 2 * B;
	fprintf(stderr, "C2: base=%d dif=%d umin=%d umax=%d\n", base, dif, umin, umax);
	if (dif < 0) return base + dif * umax;
	return base + dif * umin;
}

// Minimize: 3 * B * u +
//  A * (X[0] + X[1] + X[2] - 6 * u - 2 * min{X[2] - 2 * u, X[0] + X[1] - 4 * u}) +
//  B * min{X[2] - 2 * u, X[0] + X[1] - 4 * u}
// Optionally, we may use C at most once.

int SolveCase3(int X0, int X1, int X2) {
	// X2 - 2 * u <= X0 + X1 - 4 * u <=> u <= (X0 + X1 - X2) / 2
	if (X0 + X1 - X2 < 0) return INF;
	int umax = (X0 + X1 - X2) / 2;
	assert(umax <= (X0 + X1 + X2) / 6);
	if (umax < 0) return INF;
	if (umax > X0 / 2) umax = X0 / 2;
	// 3 * B * u + A * (X0 + X1 + X2 - 6 * u - 2 * (X2 - 2 * u)) + B * (X2 - 2 * u) =
	// A * (X0 + X1 - X2) + B * X2 + u * (B - 2 * A)
	const int base = A * (X0 + X1 - X2) + B * X2;
	const int dif = B - 2 * A;
	fprintf(stderr, "C3: base=%d dif=%d umax=%d\n", base, dif, umax);
	if (dif < 0) return base + dif * umax;
	return base;
}

int SolveCase4(int X0, int X1, int X2) {
	// X2 - 2 * u > X0 + X1 - 4 * u <=> u > (X0 + X1 - X2) / 2
	int umin = X0 + X1 - X2 < 0 ? 0 : (X0 + X1 - X2) / 2 + 1;
	if (umin < 0) umin = 0;
	const int umax = X0 / 2;
	if (umin > umax) return INF;
	// 3 * B * u + A * (X0 + X1 + X2 - 6 * u - 2 * (X0 + X1 - 4 * u)) + B * (X0 + X1 - 4 * u) =
	// A * (X2 - X0 - X1) + B * (X0 + X1) + u * (-B + 2 * A)
	const int base = A * (X2 - X0 - X1) + B * (X0 + X1);
	const int dif = -B + 2 * A;
	fprintf(stderr, "C4: base=%d dif=%d umin=%d umax=%d\n", base, dif, umin, umax);
	if (dif < 0) return base + dif * umax;
	return base + dif * umin;
}

int Solve() {
	sort(&X[0], &X[3]);
	if (B > 2 * A) B = 2 * A;
	if (C > 3 * A) C = 3 * A;
	if (C * 2 > B * 3) {
		const int v1 = SolveCase3(X[0], X[1], X[2]), v2 = SolveCase4(X[0], X[1], X[2]);
		const int v3 = C + SolveCase3(X[0] - 1, X[1] - 1, X[2] - 1), v4 = C + SolveCase4(X[0] - 1, X[1] - 1, X[2] - 1);
		fprintf(stderr, "A: X0=%d X1=%d X2=%d A=%d B=%d C=%d: v1=%d v2=%d v3=%d v4=%d\n", X[0], X[1], X[2], A, B, C, v1, v2, v3, v4);
		return min({v1, v2, v3, v4});
	} else {
		const int v1 = SolveCase1(), v2 = SolveCase2();
		fprintf(stderr, "B: X0=%d X1=%d X2=%d A=%d B=%d C=%d: v1=%d v2=%d\n", X[0], X[1], X[2], A, B, C, v1, v2);
		return min(v1, v2);	
	}
}

int main() {
	int T;
	scanf("%d", &T);
	while (T--) {
		scanf("%d %d %d %d %d %d", &X[0], &X[1], &X[2], &A, &B, &C);
		printf("%d\n", Solve());
	}	
	return 0;
}