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

using ll = long long;
using ld = long double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

template<typename Fun>
struct y_combinator {
    const Fun fun;

    explicit y_combinator(const Fun&& fun) : fun(std::forward<const Fun>(fun)) {}

    template<typename... Args>
    auto operator()(Args&&... args) const {
        return fun(std::ref(*this), std::forward<Args>(args)...);
    }
};

void solve(int /* test_num */) {
    int n;
    cin >> n;
    const int N = (1 << (n + 1));
    vector<int> a(N);
    for (int i = 2; i < N; i++) {
        cin >> a[i];
    }

    auto [dp, st] = y_combinator([&](auto solve, int v) -> pair<vector<bool>, set<int>> {
        int left = 2 * v, right = 2 * v + 1;
        if (left >= N) {
            return {vector<bool>(1, true), set<int>{a[v]}};
        }

        auto [ldp, lst] = solve(left);
        auto [rdp, rst] = solve(right);

        bool intersects = false;
        set<int> nst;
        for (auto x : lst) {
            if (rst.count(x)) {
                intersects = true;
            }
            nst.insert(x + a[v]);
        }
        for (auto x : rst) {
            nst.insert(x + a[v]);
        }

        assert(len(ldp) == len(rdp));
        const int M = len(ldp);
        vector<bool> ndp(2 * M);

        int lg = 0;
        while (M != (1 << lg)) {
            lg++;
        }

        for (int lmask = 0; lmask < M; lmask++) {
            for (int rmask = 0; rmask < M; rmask++) {
                if (!ldp[lmask] || !rdp[rmask]) {
                    continue;
                }

                int nmask = 0, carry = 0;
                for (int i = 0; i < lg; i++) {
                    carry += (lmask >> i & 1) + (rmask >> i & 1);
                    if (carry >= 1) {
                        carry--;
                        nmask ^= (1 << i);
                    }
                }

                if (carry > 0) {
                    continue;
                }

                nmask *= 2;
                if (intersects) {
                    nmask ^= 1;
                }
                ndp[nmask] = true;
            }
        }

        return {ndp, nst};
    })(1);

    int ans = 1e9;
    for (int mask = 0; mask < len(dp); mask++) {
        if (dp[mask]) {
            ans = min(ans, __builtin_popcount(mask));
        }
    }
    if (ans > 1e8) {
        ans = -1;
    }
    cout << ans << '\n';
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int tests;
    cin >> tests;
    for (int test_num = 1; test_num <= tests; test_num++) {
        solve(test_num);
    }
}