Problem: Recently a lot of students were enrolled in Berland State University. All students were divided into groups according to their education program. Some groups turned out to be too large to attend lessons in the same auditorium, so these groups should be divided into two subgroups. Your task is to help divide the first-year students of the computer science faculty.

There are t new groups belonging to this faculty. Students have to attend classes on three different subjects — maths, programming and P. E. All classes are held in different places according to the subject — maths classes are held in auditoriums, programming classes are held in computer labs, and P. E. classes are held in gyms.

Each group should be divided into two subgroups so that there is enough space in every auditorium, lab or gym for all students of the subgroup. For the first subgroup of the i-th group, maths classes are held in an auditorium with capacity of a_{i, 1} students; programming classes are held in a lab that accomodates up to b_{i, 1} students; and P. E. classes are held in a gym having enough place for c_{i, 1} students. Analogically, the auditorium, lab and gym for the second subgroup can accept no more than a_{i, 2}, b_{i, 2} and c_{i, 2} students, respectively.

As usual, some students skip some classes. Each student considers some number of subjects (from 0 to 3) to be useless — that means, he skips all classes on these subjects (and attends all other classes). This data is given to you as follows — the i-th group consists of:

  1. d_{i, 1} students which attend all classes; 
  2. d_{i, 2} students which attend all classes, except for P. E.; 
  3. d_{i, 3} students which attend all classes, except for programming; 
  4. d_{i, 4} students which attend only maths classes; 
  5. d_{i, 5} students which attend all classes, except for maths; 
  6. d_{i, 6} students which attend only programming classes; 
  7. d_{i, 7} students which attend only P. E. 



There is one more type of students — those who don't attend any classes at all (but they, obviously, don't need any place in auditoriums, labs or gyms, so the number of those students is insignificant in this problem).

Your task is to divide each group into two subgroups so that every auditorium (or lab, or gym) assigned to each subgroup has enough place for all students from this subgroup attending the corresponding classes (if it is possible). Each student of the i-th group should belong to exactly one subgroup of the i-th group; it is forbidden to move students between groups.

Input

The first line contains one integer t (1 ≤ t ≤ 300) — the number of groups.

Then the descriptions of groups follow. The description of the i-th group consists of three lines:

  * the first line contains three integers a_{i, 1}, b_{i, 1} and c_{i, 1} (1 ≤ a_{i, 1}, b_{i, 1}, c_{i, 1} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the first subgroup of the i-th group, respectively; 
  * the second line contains three integers a_{i, 2}, b_{i, 2} and c_{i, 2} (1 ≤ a_{i, 2}, b_{i, 2}, c_{i, 2} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the second subgroup of the i-th group, respectively; 
  * the third line contains integers d_{i, 1}, d_{i, 2}, ..., d_{i, 7} (0 ≤ d_{i, j} ≤ 3000) — the number of students belonging to each of the seven aforementioned types in the i-th group. It is not guaranteed that the sum of these values is positive — a group can consist entirely of students that don't attend classes at all. 



It is guaranteed that the total number of students in all groups is not greater than 3000.

Output

For each group, print the result of its division as follows:

  * if it is impossible to divide the group, print one integer -1; 
  * otherwise print seven integers f_{i, 1}, f_{i, 2}, ..., f_{i, 7} (0 ≤ f_{i, j} ≤ d_{i, j}) — the number of students the first, second, ..., seventh type in the first subgroup of the i-th group (all other students will be assigned to the second subgroup). If there are multiple answers, print any of them. 

Example

Input


3
9 4 13
1 10 3
1 2 3 4 5 6 7
9 4 13
1 10 3
2 1 3 4 5 6 7
1 2 3
4 5 6
0 0 0 0 0 0 0


Output


1 1 3 4 2 0 7
-1
0 0 0 0 0 0 0

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9, oo = numeric_limits<double>::infinity();
double simplexMethodPD(vector<vector<double>> &A, vector<double> &b,
                       vector<double> &c, vector<double> &x) {
  int n = c.size(), m = b.size();
  vector<vector<double>> T(m + 1, vector<double>(n + m + 1));
  vector<int> base(n + m), row(m);
  for (int j = 0; j < m; ++j) {
    for (int i = 0; i < n; ++i) T[j][i] = A[j][i];
    T[j][n + j] = 1;
    base[row[j] = n + j] = 1;
    T[j][n + m] = b[j];
  }
  for (int i = 0; i < n; ++i) T[m][i] = c[i];
  while (1) {
    int p = 0, q = 0;
    for (int i = 0; i < n + m; ++i)
      if (T[m][i] <= T[m][p]) p = i;
    for (int j = 0; j < m; ++j)
      if (T[j][n + m] <= T[q][n + m]) q = j;
    double t = min(T[m][p], T[q][n + m]);
    if (t >= -eps) {
      x = vector<double>(n);
      for (int i = 0; i < m; ++i)
        if (row[i] < n) x[row[i]] = T[i][n + m];
      return -T[m][n + m];
    }
    if (t < T[q][n + m]) {
      for (int j = 0; j < m; ++j)
        if (T[j][p] >= eps)
          if (T[j][p] * (T[q][n + m] - t) >= T[q][p] * (T[j][n + m] - t)) q = j;
      if (T[q][p] <= eps) return oo;
    } else {
      for (int i = 0; i < n + m + 1; ++i) T[q][i] = -T[q][i];
      for (int i = 0; i < n + m; ++i)
        if (T[q][i] >= eps)
          if (T[q][i] * (T[m][p] - t) >= T[q][p] * (T[m][i] - t)) p = i;
      if (T[q][p] <= eps) return -oo;
    }
    for (int i = 0; i < m + n + 1; ++i)
      if (i != p) T[q][i] /= T[q][p];
    T[q][p] = 1;
    base[p] = 1;
    base[row[q]] = 0;
    row[q] = p;
    for (int j = 0; j < m + 1; ++j)
      if (j != q) {
        double alpha = T[j][p];
        for (int i = 0; i < n + m + 1; ++i) T[j][i] -= T[q][i] * alpha;
      }
  }
  return oo;
}
bool SolveInteger(vector<vector<double>> &A, vector<double> &B,
                  vector<double> &C, long long &best,
                  vector<long long> &solution) {
  vector<double> x;
  double v = simplexMethodPD(A, B, C, x);
  if (v == oo || v == -oo) return false;
  if ((long long)ceil(v) >= best) return true;
  for (int i = 0; i < (int)x.size(); ++i) {
    double a = floor(x[i]);
    double b = ceil(x[i]);
    if (min(x[i] - a, b - x[i]) >= eps) {
      vector<vector<double>> NA = A;
      vector<double> NB = B;
      int vars = C.size();
      vector<double> nv(vars);
      nv[i] = -1;
      NA.push_back(nv);
      NB.push_back(-b);
      bool ok = SolveInteger(NA, NB, C, best, solution);
      NA.pop_back();
      NB.pop_back();
      nv[i] = 1;
      NA.push_back(nv);
      NB.push_back(a);
      ok |= SolveInteger(NA, NB, C, best, solution);
      return ok;
    }
  }
  auto cur_value = (long long)round(v);
  if (cur_value < best) {
    best = cur_value;
    solution = vector<long long>(x.begin(), x.end());
  }
  return true;
}
class SimplexSolutionInteger {
 public:
  long long value;
  vector<long long> solution;
  SimplexSolutionInteger(long long value, vector<long long> solution)
      : value(value), solution(move(solution)) {}
  bool has_solution() { return !solution.empty(); }
};
class SimplexSolution {
 public:
  double value;
  vector<double> solution;
  SimplexSolution(double value, vector<double> solution)
      : value(value), solution(move(solution)) {}
  bool has_solution() { return !solution.empty(); }
};
class Equation {
 public:
  vector<double> *lhs;
  double *__rhs;
  Equation(vector<double> *lhs, double *rhs) : lhs(lhs), __rhs(rhs) {}
  double &operator[](int u) { return (*lhs)[u]; }
  double &rhs() { return *__rhs; }
};
class Simplex {
  vector<vector<double>> A;
  vector<double> b;
  vector<double> c;

 public:
  Simplex(int variables) { c = vector<double>(variables); }
  int variables() { return c.size(); }
  void add_equation() {
    A.push_back(vector<double>(variables()));
    b.push_back(0);
  }
  void add_equation(vector<double> eq, double limit) {
    A.push_back(eq);
    b.push_back(limit);
  }
  Equation operator[](int ix) {
    if (ix < 0) {
      ix = A.size() + ix;
    }
    return Equation(&A[ix], &b[ix]);
  }
  vector<double> &target() { return c; }
  SimplexSolution solve() {
    vector<double> x;
    double value = simplexMethodPD(A, b, c, x);
    return SimplexSolution(value, x);
  }
  SimplexSolutionInteger solve_integer() {
    vector<long long> solution;
    long long value = (1LL << 63) - 1;
    if (SolveInteger(A, b, c, value, solution)) {
      return SimplexSolutionInteger(value, solution);
    } else {
      return SimplexSolutionInteger(numeric_limits<long long>::infinity(),
                                    vector<long long>());
    }
  }
};
using namespace std;
class FDivideTheStudents {
 public:
  void solve(std::istream &in, std::ostream &out) {
    int t;
    in >> t;
    while (t--) {
      vector<int> a(6), b(7);
      for (int i = 0; i < 6; ++i) {
        in >> a[i];
      }
      for (int i = 0; i < 7; ++i) {
        in >> b[i];
      }
      Simplex simplex(7);
      for (int i = 0; i < 7; ++i) {
        simplex.add_equation();
        simplex[-1][i] = +1;
        simplex[-1].rhs() = b[i];
      }
      for (int i = 0; i < 3; ++i) {
        simplex.add_equation();
        simplex.add_equation();
        simplex[-2].rhs() = a[i];
        simplex[-1].rhs() = a[3 + i];
        for (int j = 0; j < 7; ++j) {
          if ((j >> (2 - i) & 1) == 0) {
            simplex[-2][j] = +1;
            simplex[-1][j] = -1;
            simplex[-1].rhs() -= b[j];
          }
        }
      }
      auto solution = simplex.solve_integer();
      if (solution.has_solution()) {
        for (auto x : solution.solution) {
          out << x << " ";
        }
        out << endl;
      } else {
        out << -1 << endl;
      }
    }
  }
};
int main() {
  FDivideTheStudents solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}