#include <iostream>
#include <algorithm>
#include <cmath>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 2e4 + 10;

int n, L;

struct Point
{
    lf x, y;
    Point(lf _x = 0, lf _y = 0) : x(_x), y(_y) {}
    Point operator + (const Point u) const {return Point(x + u.x, y + u.y);}
    Point operator - (const Point u) const {return Point(x - u.x, y - u.y);}
    lf operator * (const Point u) const {return x * u.x + y * u.y;}
    lf operator ^ (const Point u) const {return x * u.y - y * u.x;}
}a1[MAXN], a2[MAXN], sg[MAXN], b1, b2, ln;

bool type[MAXN];
lf mult[MAXN], pos1[MAXN], pos2[MAXN], dis1[MAXN], dis2[MAXN];
lf pt[MAXN]; int tot;

struct Data
{
    lf k, b; int id;
    Data(lf _k = 0, lf _b = 1e18, int _id = 0) : k(_k), b(_b), id(_id) {}
    lf Calc(lf x) {return k * x + b;}
};

struct SegTree
{
    Data tr[MAXN << 2];
    void Build(int cur, int l, int r)
    {
        tr[cur] = Data();
        if (l == r) return;
        int mid = l + r >> 1;
        Build(cur << 1, l, mid), Build(cur << 1 | 1, mid + 1, r);
    }
    void Update(int cur, int l, int r, int x, int y, Data k)
    {
        // cerr << "Up " << cur << ' ' << l << ' ' << r << '\n';
        // cerr << tr[cur].k << ' ' << tr[cur].b << ' ' << k.k << ' ' << k.b << '\n';
        if (x <= l && r <= y)
        {
            if (k.Calc(pt[l]) < tr[cur].Calc(pt[l]) && k.Calc(pt[r]) < tr[cur].Calc(pt[r])) return tr[cur] = k, void();
            if (k.Calc(pt[l]) > tr[cur].Calc(pt[l]) && k.Calc(pt[r]) > tr[cur].Calc(pt[r])) return;
        }
        int mid = l + r >> 1;
        if (x <= mid) Update(cur << 1, l, mid, x, y, k);
        if (y > mid) Update(cur << 1 | 1, mid + 1, r, x, y, k);
    }
    pair <lf, int> Query(int cur, int l, int r, int x)
    {
        auto res = make_pair(tr[cur].Calc(pt[x]), tr[cur].id);
        if (l == r) return res;
        int mid = l + r >> 1;
        if (x <= mid) res = min(res, Query(cur << 1, l, mid, x));
        else res = min(res, Query(cur << 1 | 1, mid + 1, r, x));
        return res;
    }
}S[2];

lf f[MAXN], g[MAXN];

inline void Solve()
{
    Read(n);
    for (int i = 1; i <= n; i++)
        Read(a1[i].x), Read(a1[i].y), Read(a2[i].x), Read(a2[i].y), sg[i] = a2[i] - a1[i];
    Read(b1.x), Read(b1.y), Read(b2.x), Read(b2.y), Read(L);
    ln = b2 - b1, tot = 0;
    lf len = sqrt(ln * ln);
    for (int i = 1; i <= n; i++)
    {
        type[i] = ((a1[i] - b1) ^ ln) > 0;
        mult[i] = fabs(1.0 / (sg[i] * ln) * len * sqrt(sg[i] * sg[i]));
        pt[++tot] = pos1[i] = (a1[i] - b1) * ln / len;
        pt[++tot] = pos2[i] = (a2[i] - b1) * ln / len;
        dis1[i] = fabs(((a1[i] - b1) ^ ln) / len);
        dis2[i] = fabs(((a2[i] - b1) ^ ln) / len);
    }
    sort(pt + 1, pt + tot + 1), tot = unique(pt + 1, pt + tot + 1) - pt - 1;
    // for (int i = 1; i <= tot; i++) cout << pt[i] << ' '; cout << '\n';
    // for (int i = 1; i <= n; i++) cout << mult[i] << ' '; cout << '\n';
    // cout << tot << "\n";
    S[0].Build(1, 1, tot), S[1].Build(1, 1, tot);
    for (int i = 1; i <= n; i++)
    {
        Data cur = Data((dis2[i] - dis1[i]) / (pos2[i] - pos1[i]), (dis1[i] * pos2[i] - dis2[i] * pos1[i]) / (pos2[i] - pos1[i]), i);
        int lb = lower_bound(pt + 1, pt + tot + 1, pos1[i]) - pt, rb = lower_bound(pt + 1, pt + tot + 1, pos2[i]) - pt;
        if (lb > rb) swap(lb, rb); rb--;
        S[type[i]].Update(1, 1, tot, lb, rb, cur);
    }
    for (int i = 1; i < tot; i++)
    {
        auto c1 = S[0].Query(1, 1, tot, i), c2 = S[1].Query(1, 1, tot, i);
        g[i] = (c1.second ? mult[c1.second] : 0) + (c2.second ? mult[c2.second] : 0), f[i] = f[i - 1] + g[i] * (pt[i + 1] - pt[i]);
        // cout << g[i] << ' ' << f[i] << '\n';
    }
    // cout << "#\n";
    lf ans = 0;
    for (int i = 1; i < tot; i++)
    {
        int nxt = lower_bound(pt + 1, pt + tot + 1, pt[i] + L) - pt - 1;
        // cout << i << ' ' << nxt << '\n';
        ans = max(ans, f[nxt - 1] - f[i - 1] + g[nxt] * (pt[i] + L - pt[nxt]));
        // cout << ans << "\n";
    }
    for (int i = tot - 1; i; i--)
    {
        int nxt = lower_bound(pt + 1, pt + tot + 1, pt[i + 1] - L) - pt;
        ans = max(ans, f[i] - f[nxt - 1] + g[nxt - 1] * (pt[nxt] - pt[i + 1] + L));
    }
    cout << ans << '\n';
}

int main()
{
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    cout.precision(10);
    int T;
    Read(T);
    while (T--) Solve();
    return 0;
}