#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const LL inf = 1ll << 60ll;

struct Node {
    LL H, D, C;
    bool operator < (const Node& rhs) const {
        return H < rhs.H;
    }
};

struct Hit {
    LL dam, cost;
    Hit() {}
    Hit(LL a, LL b) : dam(a), cost(b) {}
    bool operator < (const Hit& rhs) const {
        return dam < rhs.dam;
    }
    bool operator == (const Hit& rhs) const {
        return dam == rhs.dam;
    }
    bool operator <= (const Hit& rhs) const {
        return dam <= rhs.dam;
    }
};

vector<Hit> X, Y;
Node A[5];
LL N, ret;

void solve(vector<Hit> &A, vector<Hit> &B) {
    LL cost = inf, dam = inf;
    vector<Hit> F(A.size());
    F[A.size() - 1] = A.back();
    for (int i = A.size() - 2; i >= 0; -- i) {
        F[i] = A[i];
        if (F[i + 1].cost < F[i].cost) F[i] = F[i + 1];
    }
    for (size_t i = 0; i < B.size(); ++ i) {
        size_t idx = lower_bound(A.begin(), A.end(), Hit(N - B[i].dam, 0)) - A.begin();
        if (idx != A.size()) {
            LL nowcost = F[idx].cost + B[i].cost, nowdam = F[idx].dam + B[i].dam;
            if (nowcost < cost || (nowcost == cost && nowdam < dam)) {
                cost = nowcost; dam = nowdam;
            }
        }
    }
    printf("%lld %lld\n", cost, dam);
}

int main() {
    int T; scanf("%d", &T);
    while (T --) {
        scanf("%lld", &N);
        ret = 0;
        for (int i = 0; i < 5; ++ i) {
            scanf("%lld%lld%lld", &A[i].H, &A[i].D, &A[i].C);
            ret += A[i].H * A[i].D;
        }
        if (ret < N) {
            puts("We are doomed!!");
            continue;
        }
        sort(A, A + 5);
        X.clear(); Y.clear();
        for (int i = 0; i <= A[0].H; ++ i) {
            for (int j = 0; j <= A[1].H; ++ j) {
                for (int k = 0; k <= A[2].H; ++ k) {
                    X.push_back(Hit(i * A[0].D + j * A[1].D + k * A[2].D, i * A[0].C + j * A[1].C + k * A[2].C));
                }
            }
        }
        for (int i = 0; i <= A[3].H; ++ i) {
            for (int j = 0; j <= A[4].H; ++ j) {
                Y.push_back(Hit(i * A[3].D + j * A[4].D, i * A[3].C + j * A[4].C));
            }
        }
        sort(X.begin(), X.end());
        sort(Y.begin(), Y.end());
        if (X.size() < Y.size()) solve(X, Y);
        else solve(Y, X);
    }
    return 0;
}