#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
using ld = long double;
using db = double; 
using str = string;
 
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
 
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>; 
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>; 
using vpd = vector<pd>;
using vvl = vector<vector<ll>>;

// // pairs
// #define mp make_pair
// #define f first
// #define s second

// vectors
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend() 
#define sor(x) sort(all(x)) 
#define rsz resize
#define ins insert 
#define ft front() 
#define bk back()
#define pf push_front 
#define pb push_back
#define eb emplace_back 
#define lb lower_bound 
#define ub upper_bound

// loops
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

const ll INF = 1e18; // not too close to LLONG_MAX
const ld PI = acos((ld)-1);
const int xd[4] = {1,0,-1,0}, yd[4] = {0,1,0,-1}; // for every grid problem!! 

// helper funcs
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down

// TO_STRING
#define ts to_string

// INPUT
 
template<class T> void re(T& x) { cin >> x; }

// OUTPUT
template<class T> void pr(T x) { cout << ts(x); }
template<class T> void prs(T x) { cout << ts(x) << ' '; }
template<class T> void prl(T x) { cout << ts(x) << endl; }
template<class T> void prv(T x) {F0R(i, sz(x)){ prs(x[i]); } cout << endl; }
template<class T> void prvsz(T x) { cout << sz(x) << endl; F0R(i, sz(x)){ prs(x[i]); } cout << endl;}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

vl x(4), y(4);

// ll min_dist(vl a, vl b){
//     ll ans = INF;
//     for(int i = 0; i < 4; i++)
//         for(int j = 0; j < 4; j++)
//             for(int k = 0; k < 4; k++)
//                 for(int l = 0; l < 4; l++){
//                     set<int> s;
//                     s.insert(i);
//                     s.insert(j);
//                     s.insert(k);
//                     s.insert(l);
//                     if(s.size() < 4)
//                         continue;
//                     ans = min(ans, abs(x[0] - a[i]) + abs(y[0] - b[i]) + abs(x[1] - a[j]) + abs(y[1] - b[j]) + abs(x[2] - a[k]) + abs(y[2] - b[k]) + abs(x[3] - a[l]) + abs(y[3] - b[l]));
//                 }
//     return ans;
// }

ll min_dist(vl a, vl b){
    ll ans = INF;
    vector<int> pp = {0, 1, 2, 3};
    do{
        int i = pp[0];
        int j = pp[1];
        int k = pp[2];
        int l = pp[3];
        ans = min(ans, abs(x[0] - a[i]) + abs(y[0] - b[i]) + abs(x[1] - a[j]) + abs(y[1] - b[j]) + abs(x[2] - a[k]) + abs(y[2] - b[k]) + abs(x[3] - a[l]) + abs(y[3] - b[l]));
    }while(next_permutation(pp.begin(), pp.end()));         
    return ans;
}




void solve(){
    ll ans = INF;
    vl a, b;
    for(int i = 0; i < 4; i++){
        cin >> x[i] >> y[i];
        a.pb(x[i]);
        b.pb(y[i]);
    }
    
    for(auto p: a)
        for(auto q: a)
            for(auto r: b){
                if(p == q)
                    continue;
                ll seg = abs(p - q);
                ll s = r + seg;
                vl xx = {p, p, q, q};
                vl yy = {r, s, r, s};
                ans = min(ans, min_dist(xx, yy));
                s = r - seg;
                yy = {r, s, r, s};
                ans = min(ans, min_dist(xx, yy));
            }

    for(auto p: b)
        for(auto q: b)
            for(auto r: a){
                if(p == q)
                    continue;
                ll seg = abs(p - q);
                ll s = r + seg;
                vl xx = {r, s, r, s};
                vl yy = {p, p, q, q};
                ans = min(ans, min_dist(xx, yy));
                s = r - seg;
                xx = {r, s, r, s};
                ans = min(ans, min_dist(xx, yy));
            }
    
    cout << ans << endl;
    
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);
    ll t = 1;
    cin >> t;
    while(t--)
        solve();
}