#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define RREP(i,s,e) for (i = s; i >= e; i--)
#define rrep(i,n) RREP(i,n,0)
#define REP(i,s,e) for (i = s; i < e; i++)
#define rep(i,n) REP(i,0,n)
#define INF 100000000

typedef long long ll;

vector<pair<int,int>> integrate(vector<pair<int,int>> a, vector<pair<int,int>> b) {
    vector<pair<int,int>> ret;
    int ia, ib;
    ia = ib = 0;
    while (ia < a.size() && ib < b.size()) {
        if (a[ia].second < b[ib].first) {
            ia++;
            continue;
        }
        else if (b[ib].second < a[ia].first) {
            ib++;
            continue;
        }
        ret.push_back(make_pair(max(a[ia].first,b[ib].first),min(a[ia].second,b[ib].second)));
        if (a[ia].second <= b[ib].second)
            ia++;
        else
            ib++;
    }
    return ret;
}

int main() {
    int t, k;
    cin >> t;
    rep (k,t) {
        int i, j, l, cnt, ans;
        int a[3][3];
        vector<pair<int,int>> r1, r2;
        cin >> l;
        rep (i,3) rep (j,3) cin >> a[i][j];
        r1.push_back(make_pair(1,l-1));
        rep (i,3) {
            rep (j,3) {
                if (a[i][j] == 0) {
                    if (i == 1) {
                        if (min(a[0][j],a[2][j]) > 1)
                            r2.push_back(make_pair(1,min({a[0][j]-1,a[2][j]-1,l-1})));
                        if (max(a[0][j],a[2][j]) < l-1)
                            r2.push_back(make_pair(max(a[0][j],a[2][j])+1,l-1));
                    }
                    else if (i == 0) {
                        if (a[1][j] < a[2][j]) {
                            if (a[2][j] - a[1][j] > 1 && l-1 > a[1][j])
                                r2.push_back(make_pair(a[1][j]+1,min(a[2][j]-1,l-1)));
                            if (a[2][j] < l-1)
                                r2.push_back(make_pair(a[2][j]+1,l-1));
                        }
                        else {
                            if (a[2][j] > 1)
                                r2.push_back(make_pair(1,min(a[2][j]-1,l-1)));
                            if (a[1][j] - a[2][j] > 1 && l-1 > a[2][j])
                                r2.push_back(make_pair(a[2][j]+1,min(a[1][j]-1,l-1)));
                        }
                    }
                    else {
                        if (a[1][j] < a[0][j]) {
                            if (a[0][j] - a[1][j] > 1 && l-1 > a[1][j])
                                r2.push_back(make_pair(a[1][j]+1,min(a[0][j]-1,l-1)));
                            if (a[0][j] < l-1)
                                r2.push_back(make_pair(a[0][j]+1,l-1));
                        }
                        else {
                            if (a[0][j] > 1)
                                r2.push_back(make_pair(1,min(a[0][j]-1,l-1)));
                            if (a[1][j] - a[0][j] > 1 && l-1 > a[0][j])
                                r2.push_back(make_pair(a[0][j]+1,min(a[1][j]-1,l-1)));
                        }
                    }
                    r1 = integrate(r1,r2);
                    r2.clear();
                    if (j == 1) {
                        if (min(a[i][0],a[i][2]) > 1)
                            r2.push_back(make_pair(1,min({a[i][0]-1,a[i][2]-1,l-1})));
                        if (max(a[i][0],a[i][2]) < l-1)
                            r2.push_back(make_pair(max(a[i][0],a[i][2])+1,l-1));
                    }
                    else if (j == 0) {
                        if (a[i][1] < a[i][2]) {
                            if (a[i][2] - a[i][1] > 1 && l-1 > a[i][1])
                                r2.push_back(make_pair(a[i][1]+1,min(a[i][2]-1,l-1)));
                            if (a[i][2] < l-1)
                                r2.push_back(make_pair(a[i][2]+1,l-1));
                        }
                        else {
                            if (a[i][2] > 1)
                                r2.push_back(make_pair(1,min(a[i][2]-1,l-1)));
                            if (a[i][1] - a[i][2] > 1 && l-1 > a[i][2])
                                r2.push_back(make_pair(a[i][2]+1,min(a[i][1]-1,l-1)));
                        }
                    }
                    else {
                        if (a[i][1] < a[i][0]) {
                            if (a[i][0] - a[i][1] > 1 && l-1 > a[i][1])
                                r2.push_back(make_pair(a[i][1]+1,min(a[i][0]-1,l-1)));
                            if (a[i][0] < l-1)
                                r2.push_back(make_pair(a[i][0]+1,l-1));
                        }
                        else {
                            if (a[i][0] > 1)
                                r2.push_back(make_pair(1,min(a[i][0]-1,l-1)));
                            if (a[i][1] - a[i][0] > 1 && l-1 > a[i][0])
                                r2.push_back(make_pair(a[i][0]+1,min(a[i][1]-1,l-1)));
                        }
                    }
                    r1 = integrate(r1,r2);
                    r2.clear();
                    if (i == j) {
                        if (i == 1) {
                            if (min(a[0][0],a[2][2]) > 1)
                                r2.push_back(make_pair(1,min({a[0][0]-1,a[2][2]-1,l-1})));
                            if (max(a[0][0],a[2][2]) < l-1)
                                r2.push_back(make_pair(max(a[0][0],a[2][2])+1,l-1));
                        }
                        else if (i == 0) {
                            if (a[1][1] < a[2][2]) {
                                if (a[2][2] - a[1][1] > 1 && l-1 > a[1][1])
                                    r2.push_back(make_pair(a[1][1]+1,min(a[2][2]-1,l-1)));
                                if (a[2][2] < l-1)
                                    r2.push_back(make_pair(a[2][2]+1,l-1));
                            }
                            else {
                                if (a[2][2] > 1)
                                    r2.push_back(make_pair(1,min(a[2][2]-1,l-1)));
                                if (a[1][1] - a[2][2] > 1 && l-1 > a[2][2])
                                    r2.push_back(make_pair(a[2][2]+1,min(a[1][1]-1,l-1)));
                            }
                        }
                        else {
                            if (a[1][1] < a[0][0]) {
                                if (a[0][0] - a[1][1] > 1 && l-1 > a[1][1])
                                    r2.push_back(make_pair(a[1][1]+1,min(a[0][0]-1,l-1)));
                                if (a[0][0] < l-1)
                                    r2.push_back(make_pair(a[0][0]+1,l-1));
                            }
                            else {
                                if (a[0][0] > 1)
                                    r2.push_back(make_pair(1,min(a[0][0]-1,l-1)));
                                if (a[1][1] - a[0][0] > 1 && l-1 > a[0][0])
                                    r2.push_back(make_pair(a[0][0]+1,min(a[1][1]-1,l-1)));
                            }
                        }
                        r1 = integrate(r1,r2);
                        r2.clear();
                    }
                    if (i == 2-j) {
                        if (i == 1) {
                            if (min(a[0][2],a[2][0]) > 1)
                                r2.push_back(make_pair(1,min({a[0][2]-1,a[2][0]-1,l-1})));
                            if (max(a[0][2],a[2][0]) < l-1)
                                r2.push_back(make_pair(max(a[0][2],a[2][0])+1,l-1));
                        }
                        else if (i == 0) {
                            if (a[1][1] < a[2][0]) {
                                if (a[2][0] - a[1][1] > 1 && l-1 > a[1][1])
                                    r2.push_back(make_pair(a[1][1]+1,min(a[2][0]-1,l-1)));
                                if (a[2][0] < l-1)
                                    r2.push_back(make_pair(a[2][0]+1,l-1));
                            }
                            else {
                                if (a[2][0] > 1)
                                    r2.push_back(make_pair(1,min(a[2][0]-1,l-1)));
                                if (a[1][1] - a[2][0] > 1 && l-1 > a[2][0])
                                    r2.push_back(make_pair(a[2][0]+1,min(a[1][1]-1,l-1)));
                            }
                        }
                        else {
                            if (a[1][1] < a[0][2]) {
                                if (a[0][2] - a[1][1] > 1 && l-1 > a[1][1])
                                    r2.push_back(make_pair(a[1][1]+1,min(a[0][2]-1,l-1)));
                                if (a[0][2] < l-1)
                                    r2.push_back(make_pair(a[0][2]+1,l-1));
                            }
                            else {
                                if (a[0][2] > 1)
                                    r2.push_back(make_pair(1,min(a[0][2]-1,l-1)));
                                if (a[1][1] - a[0][2] > 1 && l-1 > a[0][2])
                                    r2.push_back(make_pair(a[0][2]+1,min(a[1][1]-1,l-1)));
                            }
                        }
                        r1 = integrate(r1,r2);
                        r2.clear();
                    }
                    auto tmp = r1;
                    r1.clear();
                    for (auto p = tmp.rbegin(); p != tmp.rend(); p++)
                        r1.push_back(make_pair(l-p->second,l-p->first));
                }
            }
        }
        ans = 0;
        for (auto p : r1)
            ans += p.second - p.first + 1;
        cout << ans << endl;
    }
    return 0;
}