#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<set>
#include<iomanip>
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{
    LL x, y;

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

    LL operator^(Point t){
        return x * t.y - y * t.x;
    }

    LL operator*(Point t){
        return x * t.x + y * t.y;
    }

    LL len2(){
        return x * x + y * y;
    }

};

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

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

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

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

};

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;
    }

};

long double cur_x;
Point v;

long double project(Point a){
    LL dot = a * v;
    return dot / sqrtl(v.len2());
}

long double area(long double y){
    return abs(v.x * y - v.y * cur_x);
}

struct Segment{
    Point a, b;

    long double k() const {
        LL dx = b.x - a.x;
        LL dy = b.y - a.y;
        return sqrtl(dx * dx + dy * dy) / (project(b) - project(a));
    }

    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 area(y1) < area(y2);
    }

};

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<Segment> seg(n);
        for(int i = 0; i < n; i++){
            cin >> seg[i].a.x >> seg[i].a.y >> seg[i].b.x >> seg[i].b.y;
        }
        Point a, b; long double L;
        cin >> a.x >> a.y >> b.x >> b.y >> L;
        v = b - a;

        vector<Fraction> nums;
        vector<Event> event;
        nums.reserve(2 * n);
        event.reserve(2 * n);
        
        for(int i = 0; i < n; i++){
            auto &[p1, p2] = seg[i];
            vector<Fraction> q;
            for(auto p : {p1, p2}){
                auto vv = p - a;
                LL dot = vv * v;
                nums.push_back(Fraction(dot, v.len2()));
                q.push_back(nums.back());
            }
            if (q[1] < q[0]) swap(q[0], q[1]), swap(p1, p2);
            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 - a) ^ v) > 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 - a) ^ v) > 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';
    }

}