#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


#define foreach(i, c) for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
using wint = Int;
struct Row { int j, p; wint v; };
struct Col { int i, p; };
struct Mat {
  vector<vector<Row>> rs;
  vector<vector<Col>> cs;
  void append(int i, int j, wint val) {
    if (i >= (int)rs.size()) rs.resize(i + 1);
    if (j >= (int)cs.size()) cs.resize(j + 1);
    if (val == 0) return;
    rs[i].push_back({j, (int)cs[j].size(), val});
    cs[j].push_back({i, (int)rs[i].size() - 1});
  }
  void remove(Row &r) {
    if (r.p + 1 < (int)cs[r.j].size()) { Col &c = cs[r.j].back(); cs[r.j][rs[c.i][c.p].p = r.p] = c; }
    cs[r.j].pop_back();
  }
  void remove(Col &c) {
    if (c.p + 1 < (int)rs[c.i].size()) { Row &r = rs[c.i].back(); rs[c.i][cs[r.j][r.p].p = c.p] = r; }
    rs[c.i].pop_back();
  }
  void remove(int i, int k) {
    Row r = rs[i][k]; remove(cs[r.j][r.p]); remove(r);
  }
  void clearRow(int i) {
    foreach (it, rs[i]) { remove(*it); } rs[i].clear();
  }
  void clearCol(int j) {
    foreach (it, cs[j]) { remove(*it); } cs[j].clear();
  }
  wint operator()(int i, int j) {
    foreach (it, rs[i]) { if (it->j == j) return it->v; } return 0;
  }
  wint operator()(Col &c) {
    return rs[c.i][c.p].v;
  }
};
struct Tab {
  Mat D;
  vector<int> id;
  vector<wint> tmp;
  Tab(Mat A, vector<wint> b, vector<wint> c) : id(b.size() + 1) {
    int m = b.size(), n = c.size();
    for (int i = 0; i < m; ++i) foreach (it, A.rs[i]) D.append(1 + i, 1 + it->j, it->v);
    for (int i = 0; i < m; ++i) D.append(1 + i, 0, b[i]);
    for (int j = 0; j < n; ++j) D.append(0, 1 + j, -c[j]);
    for (int i = 0; i <= m; ++i) { id[i] = 1 + n + i; D.append(i, 1 + n + i, 1); }
  }
  wint idv(int i) {
    return D(D.cs[id[i]][0]);
  }
  wint val(vector<wint> &x) {
    x.assign(id[0] - 1, 0);
    for (int i = 0; i < (int)id.size(); ++i) if (id[i] < id[0]) x[id[i] - 1] = D(i, 0) / idv(i);
    return D(0, 0) / idv(0);
  }
  void pivot(int r, int s) {
    if (tmp.size() < D.cs.size()) tmp.resize(D.cs.size(), 0);
    wint mul = (D(r, s) < 0) ? -1 : 1; foreach (it, D.rs[r]) tmp[it->j] = (it->v *= mul);
    vector<Col> cs = D.cs[s];
    foreach (it, cs) if (it->i != r) {
      wint d = D(*it), pv = tmp[s]; vector<Row> &rs = D.rs[it->i];
      for (int k = 0; k < (int)rs.size(); ++k) {
        rs[k].v = rs[k].v * pv - tmp[rs[k].j] * d; tmp[rs[k].j] = 0;
        if (rs[k].v == 0) D.remove(it->i, k--);
      }
      foreach (jt, D.rs[r]) {
        if (tmp[jt->j] == 0) tmp[jt->j] = jt->v; else D.append(it->i, jt->j, -jt->v * d);
      }
      wint g = 0; foreach (jt, rs) g = __gcd(jt->v, g); if (g < 0) g = -g;
      foreach (jt, rs) jt->v /= g;
    }
    foreach (it, D.rs[r]) { tmp[it->j] = 0; } id[r] = s;
  }
  void simplex() {
    for (int i = 1; i < (int)id.size(); ++i) if (D.rs[i].size() > 1) {
      bool ok = 1;
      foreach (it, D.rs[i]) if (it->j == 0 || it->v < 0) ok = 0;
      if (ok) { vector<Row> rs = D.rs[i]; foreach (it, rs) if (it->j != id[i]) D.clearCol(it->j); }
    }
    if (tmp.size() < D.cs.size()) tmp.resize(D.cs.size(), 0);
    for (; ; ) {
      int r = 0, s = 0;
      foreach (it, D.cs[0]) if (it->i > 0 && (r == 0 || id[r] > id[it->i]) && D(*it) < 0) r = it->i;
      if (r == 0) break;
      wint t = 0;
      foreach (it, D.rs[0]) tmp[it->j] = it->v;
      foreach (it, D.rs[r]) if (it->j > 0 && it->v < 0) {
        wint d = tmp[it->j] * t - tmp[s] * it->v;
        if (s == 0 || d > 0 || (d == 0 && s > it->j)) { s = it->j; t = it->v; }
      }
      foreach (it, D.rs[0]) tmp[it->j] = 0;
      if (s == 0) throw "infeasible";
      pivot(r, s);
    }
  }
  void crisscross() {
    for (int INF = 1001001001; ; ) {
      int r = 0, s = INF;
      foreach (it, D.cs[0]) if (it->i > 0 && (r == 0 || id[r] > id[it->i]) && D(*it) < 0) r = it->i;
      foreach (it, D.rs[0]) if (it->j > 0 && it->v < 0) chmin(s, it->j);
      if (r == 0 && s == INF) break;
      if (r > 0 && id[r] < s) {
        s = INF;
        foreach (it, D.rs[r]) if (it->j > 0 && it->v < 0) chmin(s, it->j);
        if (s == INF) throw "primal infeasible";
      } else {
        r = 0;
        foreach (it, D.cs[s]) if ((r == 0 || id[r] > id[it->i]) && D(*it) > 0) r = it->i;
        if (r == 0) throw "dual infeasible";
      }
      pivot(r, s);
    }
  }
};
wint floorDiv(wint a, wint b) {
  return (a >= 0) ? (a / b) : ((a - b + 1) / b);
}
void branch(Tab &t, int i, int k, wint f) {
  int n = t.id.size(), m = t.D.cs.size();
  t.id.push_back(m); t.D.append(n, 0, f); t.D.append(n, t.id[i], k); t.D.append(n, m, 1); t.pivot(i, t.id[i]);
}
int select(Tab &t) {
  for (int i = 0; i < (int)t.id.size(); ++i) if (t.id[i] < t.id[0] && t.D(i, 0) % t.idv(i) != 0) return i;
  return 0;
}
bool IPDfs(Tab &t, vector<wint> &x, wint lb) {
  try {
    t.simplex(); wint t0 = t.D(0, 0), ti = t.idv(0); if (t0 < lb * ti) return 0; vector<Row> rs = t.D.rs[0];
    foreach (it, rs) if (it->j > 0 && it->j != t.id[0] && t0 - it->v < lb * ti) t.D.clearCol(it->j);
    int i = select(t);
    if (i == 0) {
      t.val(x); return 1;
    } else {
      wint f = floorDiv(t.D(i, 0), t.idv(i));
      Tab tt = t;
      branch(tt, i, -1, -f - 1); if (IPDfs(tt, x, lb)) return 1;
      branch(t, i, 1, f); if (IPDfs(t, x, lb)) return 1;
    }
  } catch (...) {
  }
  return 0;
}
// max c.x subject to x >= 0, A x <= b
wint IP(Mat A, vector<wint> b, vector<wint> c, vector<wint> &x) {
  Tab t(A, b, c); t.crisscross();
  for (wint lb = floorDiv(t.D(0, 0), t.idv(0)); ; --lb) { Tab tt = t; if (IPDfs(tt, x, lb)) return lb; }
}



int K;
Int C[1 << 4], D[4];

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &K);
    for (int h = 1; h < 1 << K; ++h) {
      scanf("%lld", &C[h]);
    }
    for (int i = 0; i < K; ++i) {
      scanf("%lld", &D[i]);
    }
    
    Mat A;
    vector<wint> b;
    {
      int row = 0;
      for (int i = 0; i < K; ++i) {
        for (const int sig : {+1, -1}) {
          for (int h = 1; h < 1 << K; ++h) if (h >> i & 1) {
// cerr<<"A["<<row<<"]["<<h<<"] = "<<sig<<endl;
            A.append(row, h - 1, sig);
          }
          ++row;
          b.push_back(sig * D[i]);
        }
      }
    }
    const vector<wint> c(C + 1, C + (1 << K));
// cerr<<"b = "<<b<<endl;
// cerr<<"c = "<<c<<endl;
    vector<wint> x;
    try {
      const wint ans = IP(A, b, c, x);
      printf("%lld\n", ans);
    } catch (const char *msg) {
      cerr << "HELP " << msg << endl;
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}