#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (decay<decltype(x)>::type i = (x), _##i = (y); i > _##i; --i)
#ifdef zerol
#define dbg(x...) do { cerr << "\033[32;1m" << #x << " -> "; err(x); } while (0)
#else
#define dbg(...)
#endif // zerol
void err() { cerr << "\033[39;0m" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cerr << a << ' '; err(x...); }
// ----------------------------------------------------------------------------------------


int N = 1e7;

double get() {
    double x, y; cin >> x >> y;
    if(y == 0) return x;
    if(x == 1) return y+1;
    if(y == 1) return 3-x;
    return 4-y;
}

namespace R {
    const int maxn = 300 + 10;
    int n, m;
    int left[maxn], L[maxn], R[maxn];
    int w[maxn][maxn], slack[maxn];
    bool visL[maxn], visR[maxn];

    bool dfs(int u) {
        visL[u] = true;
        FOR (v, 0, m) {
            if (visR[v]) continue;
            int t = L[u] + R[v] - w[u][v];
            if (t == 0) {
                visR[v] = true;
                if (left[v] == -1 || dfs(left[v])) {
                    left[v] = u;
                    return true;
                }
            } else slack[v] = min(slack[v], t);
        }
        return false;
    }

    int go() {
        memset(left, -1, sizeof left);
        memset(R, 0, sizeof R);
        memset(L, 0, sizeof L);
        FOR (i, 0, n)
            FOR (j, 0, m)
                L[i] = max(L[i], w[i][j]);

        FOR (i, 0, n) {
            memset(slack, 0x3f, sizeof slack);
            while (1) {
                memset(visL, 0, sizeof visL); memset(visR, 0, sizeof visR);
                if (dfs(i)) break;
                int d = 0x3f3f3f3f;
                FOR (j, 0, m) if (!visR[j]) d = min(d, slack[j]);
                FOR (j, 0, n) if (visL[j]) L[j] -= d;
                FOR (j, 0, m) if (visR[j]) R[j] += d; else slack[j] -= d;
            }
        }
        int ret = 0;
        FOR (i, 0, m) if (left[i] != -1) ret += w[left[i]][i];
        return ret;
    }
}

int p[4];

int submit(int mou[4]) {
    FOR(i, 0, 4) dbg(i, p[i], mou[i]);
    R::n = 4; R::m = 4;
    FOR(i, 0, 4)
    FOR(j, 0, 4) {
        int dis = abs(p[i]-mou[j]);
        if(dis>2*N) dis = N*4-dis;
        R::w[i][j] = N*2-dis;
    }
    int ret = R::go();
    return N*8-ret;
}

int case1() {
    vector<int> V;
    FOR(i, 0, 4) {
        double x = p[i]%N;
        V.emplace_back(x);
        V.emplace_back(N-x);
    }
    int ans = 1e8;
    for(auto x: V) {
        int mou[4];
        mou[0] = 0*N+x;
        mou[1] = 1*N+x;
        mou[2] = 2*N+x;
        mou[3] = 3*N+x;
        ans = min(ans, submit(mou));
    }
    for(auto x: V) {
        int mou[4];
        mou[0] = 0*N+x;
        mou[1] = 2*N-x;
        mou[2] = 2*N+x;
        mou[3] = 4*N-x;
        ans = min(ans, submit(mou));
    }
    return ans;
}

int main() {
    int T; cin >> T;
    while(T--) {
        FOR(i, 0, 4) p[i] = (int)round(get()*N);
        int ans = case1();
        dbg(ans);
        printf("%.12f\n", ans*1e-7);
    }
}