#include <bits/stdc++.h>

const double eps = 1e-8;

#define lt(x, y) ((x) < (y) - eps)
#define gt(x, y) ((x) > (y) + eps)
#define le(x, y) ((x) <= (y) + eps)
#define ge(x, y) ((x) >= (y) - eps)
#define eq(x, y) (le(x, y) && ge(x, y))
#define dot(x, y, z) (((y) - (x)) * ((z) - (x)))
#define cross(x, y, z) (((y) - (x)) ^ ((z) - (x)))

struct vec2 {
    double x, y;
    vec2 (double x0 = 0.0, double y0 = 0.0) : x(x0), y(y0) {}
    vec2 * read() {scanf("%lf%lf", &x, &y); return this;}
    inline vec2 operator - () const {return vec2(-x, -y);}
    inline vec2 operator + (const vec2 &B) const {return vec2(x + B.x, y + B.y);}
    inline vec2 operator - (const vec2 &B) const {return vec2(x - B.x, y - B.y);}
    inline vec2 operator * (double k) const {return vec2(x * k, y * k);}
    inline vec2 operator / (double k) const {return *this * (1.0 / k);}
    inline double operator * (const vec2 &B) const {return x * B.x + y * B.y;}
    inline double operator ^ (const vec2 &B) const {return x * B.y - y * B.x;}
    inline double norm2() const {return x * x + y * y;}
    inline double norm() const {return sqrt(x * x + y * y);}
    inline bool operator < (const vec2 &B) const {return lt(x, B.x) || le(x, B.x) && lt(y, B.y);}
    inline bool operator == (const vec2 &B) const {return eq(x, B.x) && eq(y, B.y);}
    inline bool operator << (const vec2 &B) const {return lt(y, 0) ^ lt(B.y, 0) ? lt(B.y, 0) : gt(*this ^ B, 0) || ge(*this ^ B, 0) && ge(x, 0) && lt(B.x, 0);}
    inline vec2 trans(double a11, double a12, double a21, double a22) const {return vec2(x * a11 + y * a12, x * a21 + y * a22);}
} p[4], q[4];

inline void down(double &x, const double y) {x > y ? x = y : 0;}

inline double EE(const vec2 &A) {
    if (eq(A.x, 1)) return A.y + 1;
    if (eq(A.y, 1)) return 3 - A.x;
    if (eq(A.x, -1)) return 5 - A.y;
    if (eq(A.y, -1)) return 7 + A.x;
}

inline double DD(const vec2 &A, const vec2 &B) {
    double a = EE(A), b = EE(B), c = fabs(a - b);
    return c > 4. ? 8. - c : c;
}

inline double calc() {
    int i; double ret = 0.;
    for (i = 0; i < 4; ++i) ret += DD(p[i], q[i]);
    return ret;
}

inline vec2 mirror(const vec2 &A) {
    if (eq(A.x, 1)) return A.trans(0, 1, 1, 0);
    if (eq(A.y, 1)) return A.trans(0, -1, -1, 0);
    if (eq(A.x, -1)) return A.trans(0, 1, 1, 0);
    if (eq(A.y, -1)) return A.trans(0, -1, -1, 0);
    
}

void work() {
    int i; double ans = INFINITY;
    for (i = 0; i < 4; ++i) p[i].read(), p[i] = p[i] * 2 - vec2(1, 1);
    std::sort(p, p + 4, [] (const vec2 &A, const vec2 &B) {return A << B;});
    for (i = 0; i < 4; ++i)
        q[0] = p[0], q[1] = q[0].trans(0, -1, 1, 0), q[2] = q[1].trans(0, -1, 1, 0), q[3] = q[2].trans(0, -1, 1, 0),
        down(ans, calc()), std::rotate(p, p + 1, p + 4);
    for (i = 0; i < 4; ++i)
        q[0] = p[0], q[1] = mirror(q[0]), q[2] = mirror(q[1]), q[3] = mirror(q[2]),
        down(ans, calc()), std::rotate(p, p + 1, p + 4);
    printf("%.12lf\n", ans * .5);
}

int main() {
    int T;
    for (scanf("%d", &T); T; --T) work();
    return 0;
}