#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<set>
#include<iomanip>
#include<array>
using namespace std;
using LL = long long;

template<typename T>
T sign(T x){
    if (x > 0) return 1;
    if (x < 0) return -1;
    return 0;
}

template<typename T>
T abs(T x){
    if (x < 0) x = -x;
    return x;
}

template<typename T> 
T gcd(T a, T b){
    if (b == 0) return a;
    return gcd(b, a % b);
}

struct Point{
    long double x, y;

    Point operator+(const Point &t) const {
        return {x + t.x, y + t.y};
    }

    Point operator-(const Point &t) const {
        return {x - t.x, y - t.y};
    }

    Point operator*(long double t) const {
        return {x * t, y * t};
    }

    Point operator/(long double t) const {
        return {x / t, y / t};
    }

    long double operator*(const Point &t) const {
        return x * t.x + y * t.y;
    }

    long double operator^(const Point &t) const {
        return x * t.y - y * t.x;
    }

    long double len(){
        return sqrtl(x * x + y * y);
    }

};

struct Fraction{
    LL x, y; __int128_t v;
    long double val;

    // _x * _x / y
    Fraction(LL _x, LL _y){
        val = _x / sqrtl(_y);
        __int128_t t = __int128_t(_x) * _x * sign(_x);
        v = t / _y;
        x = t % _y;
        y = _y;
        LL g = abs(gcd(x, y));
        x /= g; y /= g;
    }

    bool operator<(const Fraction &t) const {
        if (v != t.v) return v < t.v;
        return __int128_t(x) * t.y < __int128_t(y) * t.x;
    }

    bool operator==(const Fraction &t) const {
        return v == t.v and x == t.x and y == t.y;
    }

};

long double cur_x;

struct Segment{
    Point a, b;

    long double k() const {
        return (b - a).len() / (b.x - a.x);
    }

    bool operator<(const Segment& t) const {
        long double y1 = a.y + (cur_x - a.x) / (b.x - a.x) * (b.y - a.y);
        long double y2 = t.a.y + (cur_x - t.a.x) / (t.b.x - t.a.x) * (t.b.y - t.a.y);
        return abs(y1) < abs(y2);
    }

};

struct Event{
    Fraction t; int id, type;

    bool operator<(const Event &a) const {
        if (t == a.t) return type < a.type;
        return t < a.t;
    }
};

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    cout << fixed << setprecision(10);

    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<array<LL, 4> > p(n);
        for(int i = 0; i < n; i++){
            for(auto &x : p[i]){
                cin >> x;
            }
        }
        LL x1, y1, x2, y2, L;
        cin >> x1 >> y1 >> x2 >> y2 >> L;
        Point a = {1.0L * x1, 1.0L * y1}, b = {1.0L * x2, 1.0L * y2};
        LL dx = x2 - x1, dy = y2 - y1;
        LL sqr = dx * dx + dy * dy;
        Point v1 = {1.0L * dx, 1.0L * dy};
        v1 = v1 / v1.len();
        Point v2 = v1;
        swap(v2.x, v2.y);
        v2.x = -v2.x;

        // v = {1.0L * dx, 1.0L * dy};
        // v = v / v.len();
        // a = {1.0L * x1, 1.0L * y1};
        // b = {1.0L * x2, 1.0L * y2};
        vector<Segment> seg(n);
        vector<Fraction> nums;
        vector<Event> event;
        nums.reserve(2 * n);
        event.reserve(2 * n);
        for(int i = 0; i < n; i++){
            auto [x3, y3, x4, y4] = p[i];
            vector<Fraction> q;
            {
                LL dot = (x3 - x1) * dx + (y3 - y1) * dy;
                q.push_back(Fraction(dot, sqr));
                nums.push_back(q.back());
            }
            {
                LL dot = (x4 - x1) * dx + (y4 - y1) * dy;
                q.push_back(Fraction(dot, sqr));
                nums.push_back(q.back());
            }
            if (q[1] < q[0]){
                swap(q[0], q[1]);
                swap(x3, x4);
                swap(y3, y4);
            }
            Point p1 = {1.0L * x3, 1.0L * y3};
            Point p2 = {1.0L * x4, 1.0L * y4};
            seg[i] = {{p1 * v1, p1 * v2}, {p2 * v1, p2 * v2}};
            event.push_back({q[0], i, 1});
            event.push_back({q[1], i, 0});
        }
        sort(nums.begin(), nums.end());
        nums.erase(unique(nums.begin(), nums.end()), nums.end());

        sort(event.begin(), event.end());

        vector<long double> sum(nums.size() - 1);
        vector<long double> len(nums.size() - 1);

        set<Segment> st[2];

        for(int i = 0, j = 0; i + 1 < nums.size(); i++){
            len[i] = nums[i + 1].val - nums[i].val;
            cur_x = nums[i].val;
            while(j < event.size() and (event[j].t == nums[i] and event[j].type == 0)){
                auto [_, id, type] = event[j++];
                st[seg[id].a.y > 0].erase(seg[id]);
            }
            while(j < event.size() and (event[j].t == nums[i] and event[j].type == 1)){
                auto [_, id, type] = event[j++];
                st[seg[id].a.y > 0].insert(seg[id]);
            }

            for(int k = 0; k < 2; k++){
                if (!st[k].empty()){
                    sum[i] += st[k].begin()->k() * len[i];
                }
            }
        }

        long double ans = 0, val = 0;
        for(int i = 0, j = 0; i + 1 < nums.size(); i++){
            if (i - 1 >= 0){
                val -= sum[i - 1];
            }
            while(j + 1 < nums.size() and nums[j + 1].val - nums[i].val <= L){
                val += sum[j++];
            }
            long double cur = val;
            if (nums[j].val - nums[i].val < L and j + 1 < nums.size()){
                cur += (L - (nums[j].val - nums[i].val)) / len[j] * sum[j];
            }
            ans = max(ans, cur);
        }
        val = 0;
        for(int i = nums.size() - 1, j = nums.size() - 1; i >= 1; i--){
            if (i < sum.size()){
                val -= sum[i];
            }
            while(j - 1 >= 0 and nums[i].val - nums[j - 1].val <= L){
                val += sum[--j];
            }
            long double cur = val;
            if (nums[i].val - nums[j].val < L and j - 1 >= 0){
                cur += (L - (nums[i].val - nums[j].val)) / len[j - 1] * sum[j - 1];
            }
            ans = max(ans, cur);
        }
        cout << ans << '\n';
    }

}