#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (ll i = (l); i < (r); ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using pl = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;

struct SCC {
    using Graph = vector<vector<int>>;
    Graph g, rg;

    vector<vector<int>> scc;
    vector<int> cmp;
    Graph dag;
    SCC(int n) : g(n), rg(n) {}

    void addEdge(int u, int v){
        g[u].push_back(v);
        rg[v].push_back(u);
    }

    vector<bool> seen;
    vector<int> vs,rvs;
    void dfs(int v){
        seen[v] = true;
        for(auto e: g[v]) if(!seen[e]) dfs(e);
        vs.push_back(v);
    }
    void rdfs(int v, int k){
        seen[v] = true;
        cmp[v] = k;
        for(auto e: rg[v]) if(!seen[e]) rdfs(e,k);
        rvs.push_back(v); 
    }

    void build(){
        int n = g.size();
        seen.assign(n, false);
        vs.clear();
        for(int v = 0; v < n; v++) if(!seen[v]) dfs(v);

        int k = 0;
        scc.clear();
        cmp.assign(n,-1);
        seen.assign(n,false);
        for(int i = n-1; i >= 0; i--){
            if(!seen[vs[i]]){
                rvs.clear();
                rdfs(vs[i], k++);
                scc.push_back(rvs);
            }
        }

        set<pair<int,int>> newEdges;
        int dv = scc.size();
        dag.assign(dv, vector<int>(0));
        newEdges.clear();
        for(int i = 0; i < n; i++){
            int u = cmp[i];
            for(auto e: g[i]){
                int v = cmp[e];
                if(u == v) continue;
                if(!newEdges.count({u,v})){
                    dag[u].push_back(v);
                    newEdges.insert({u,v});
                }
            }
        }
    }
};

ll p(ll x,ll m){
    if(x>=0)return x%m;
    else return (m-1)-(-x-1)%m;
}

bool dfs(vector<vector<pair<ll,ll>>> &z,vector<ll> &club,vector<ll> &kai,vector<bool> &rai,ll now){
    rai[now]=true;
    bool ans =false;
    rep(i,0,z[now].size()){
        if(club[now]==club[z[now][i].first]){
        if(!rai[z[now][i].first]){
            kai[z[now][i].first]=kai[now]+z[now][i].second;
            rai[z[now][i].first]=true;
            if((dfs(z,club,kai,rai,z[now][i].first)))ans=true;
        }
        else{
            if(kai[now]+z[now][i].second!=kai[z[now][i].first])ans=true;
        }
        }
    }
    return ans;
}


int ans(vector<int> z,ll dep,ll n,ll yoyu){
    vector<ll> f;
    ll gr=(1<<(n-(dep)-1));
    ll sg=(1<<(dep+1));
    rep(i,0,gr){
        unordered_set<int> ss;
        rep(j,0,sg){
            if(ss.count(z[i*sg+j])){
                f.push_back(i);
                break;
            }
            if(z[i*sg+j]!=-1)ss.insert(z[i*sg+j]);
            
        }
    }
    if(n==dep+1){
        if(f.size()==1)return 1;
        else return 0;
    }
    if(yoyu<f.size())return -1;
    int zans=10000;
    rep(i,0,(1<<(int)(f.size()))){
        vector<int> p=z;
        rep(j,0,(f.size())){
            if(i&(1<<j)){
                rep(k,0,sg/2){
                    p[f[j]*sg+k]=-1;
                }
            }
            else{
                rep(k,0,sg/2){
                    p[f[j]*sg+sg/2+k]=-1;
                }
            }
        }
        int t=ans(z,dep+1,n,yoyu-f.size()+1);
        if(t!=-1)zans=min(t,zans);
    }
    if(zans>1000)return -1;
    else return zans+f.size();
}


int main(){
    ll t;
    cin>>t;
    rep(ia,0,t){
        ll n;
        cin>>n;
        ll m=(1<<n);
        vector<int> z(m);
        ll p=m;
        rep(i,0,n){
            p/=2;
            rep(j,0,(1<<(i+1))){
                ll e;
                cin>>e;
                rep(k,0,p){
                    z[p*j+k]+=e;
                }
            }
        }
        cout<<ans(z,0, n,1)<<endl;
    }
}