#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<set>
#include<cassert>
#include<map>
#include<string>
#include<iostream>
#include<ext/pb_ds/priority_queue.hpp>
#include<queue>
#include<stack>
#include<bitset>
#include<tr1/unordered_map>
#include<tr1/unordered_set>
#define pb push_back
#define all(a) a.begin(),a.end()
#define pointtype double
#define pointtype_INT 0
using namespace std;
using namespace tr1;
typedef long long LL;
typedef pair<int,int>pii;
typedef unsigned uint;
typedef unsigned long long uLL;
const double pi=acos(-1);
template<class T>
void Read(T &x){
    char c;
    bool f(0);
    while(c=getchar(),c!=EOF){
        if(c=='-')
            f=1;
        else if(c>='0'&&c<='9'){
            x=c-'0';
            while(c=getchar(),c>='0'&&c<='9')
                x=x*10+c-'0';
            ungetc(c,stdin);
            if(f)
                x=-x;
            return;
        }
    }
}
struct point{
    pointtype x,y;
    inline point(){
    }
    inline point(pointtype x,pointtype y=0):x(x),y(y){
    }
    inline point operator+(const point &a)const{
        return point(x+a.x,y+a.y);
    }
    inline point operator+=(const point &a){
        return *this=*this+a;
    }
    inline point operator-(const point &a)const{
        return point(x-a.x,y-a.y);
    }
    inline point operator-=(const point &a){
        return *this=*this-a;
    }
    inline bool operator<(const point &b)const{
        if(x==b.x)
            return y<b.y;
        return x<b.x;
    }
    inline bool operator==(const point &b)const{
        return x==b.x&&y==b.y;
    }
    #if pointtype_INT==1
        inline point operator*(const point &a)const{
            return point(1ll*x*a.x-1ll*y*a.y,1ll*x*a.y+1ll*y*a.x);
        }
        inline friend LL cross(const point &a,const point &b){
            return 1ll*a.x*b.y-1ll*a.y*b.x;
        }
        inline friend LL dot(const point &a,const point &b){
            return 1ll*a.x*b.x+1ll*a.y*b.y;
        }
    #else
        inline point operator*(const point &a)const{
            return point(x*a.x-y*a.y,x*a.y+y*a.x);
        }
        inline friend pointtype cross(const point &a,const point &b){
            return a.x*b.y-a.y*b.x;
        }
        inline friend pointtype dot(const point &a,const point &b){
            return a.x*b.x+a.y*b.y;
        }
    #endif
};
template<class T,class T2>
struct hashnode{
    T val;
    T2 v;
    hashnode *next;
};
template<class T,class T2>
inline int& addhash(int u,const T &val,T2 *&ecnt,T2 **adj){
    T2 *p=++ecnt;
    p->val=val;
    p->v=0;
    p->next=adj[u];
    adj[u]=p;
    return p->v;
}
template<class T,class T2,int MOD,int ss>
class hash_table{
    hashnode<T,T2>*adj[MOD],edge[ss+10],*ecnt;
    int sz;
    public:
    inline int Get_val(int x){
        return x%MOD;
    }
    #if pointtype_INT==1
        inline int Get_val(point x){
            return (x.x*998244353ll+x.y)%MOD;
        }
    #endif
    inline hash_table():ecnt(edge),sz(0){
        for(int i=0;i<MOD;i++)
            adj[i]=0;
    }
    inline int size(){
        return sz;
    }
    inline hashnode<T,T2>* hash(const T &x){
        int t=Get_val(x);
        for(hashnode<T,T2> *p=adj[t];p;p=p->next)
            if(p->val==x)
                return p;
        return 0;
    }
    inline int &operator[](const T &x){
        hashnode<T,T2> *p=hash(x);
        if(p)
            return p->v;
        return ++sz,addhash(Get_val(x)%MOD,x,ecnt,adj);
    }
    inline bool count(const T &x){
        return hash(x);
    }
    inline void clear(){
        ecnt=edge;
        int t=MOD>>2<<2,i;
        for(i=0;i<t;i+=4){
            adj[i]=0;
            adj[i+1]=0;
            adj[i+2]=0;
            adj[i+3]=0;
        }
        for(;i<MOD;i++)
            adj[i]=0;
        sz=0;
    }
};
template<int sz,int MOD>
struct Matrix{
    int a[sz][sz];
    inline Matrix(){
        memset(a,0,sizeof a);
    }
    inline Matrix(int){
        memset(a,0,sizeof a);
        for(int i=0;i<sz;i++)
            a[i][i]=1;
    }
    inline void clear(){
        memset(a,0,sizeof a);
    }
    inline Matrix operator *(const Matrix &b)const{
        static Matrix c;
        c.clear();
        int i,j,k;
        for(i=0;i<sz;i++)
            for(j=0;j<sz;j++)
                if(a[i][j])
                    for(k=0;k<sz;k++)
                        c.a[i][k]=(c.a[i][k]+1ll*a[i][j]*b.a[j][k])%MOD;
        return c;
    }
    inline Matrix &operator *=(const Matrix &b){
        return *this=*this*b;
    }
    friend Matrix quick_pow(Matrix a,int b){
        Matrix ret(1);
        while(b){
            if(b&1)
                ret*=a;
            a*=a;
            b>>=1;
        }
        return ret;
    }
};
struct cpx{
    double r,i;
    inline cpx(){
    }
    inline cpx(double r,double i=0):r(r),i(i){
    }
    inline cpx operator+(const cpx &a)const{
        return cpx(r+a.r,i+a.i);
    }
    inline cpx operator-(const cpx &a)const{
        return cpx(r-a.r,i-a.i);
    }
    inline cpx operator*(const cpx &a)const{
        return cpx(r*a.r-i*a.i,r*a.i+i*a.r);
    }
    inline cpx operator/(const double &a)const{
        return cpx(r/a,i/a);
    }
    inline cpx operator/(const cpx&a)const{
        return *this*cpx(a.r,-a.i)/(a.r*a.r+a.i*a.i);
    }
    inline cpx operator+=(const cpx &a){
        return *this=*this+a;
    }
    inline cpx operator-=(const cpx &a){
        return *this=*this-a;
    }
    inline cpx operator*=(const cpx &a){
        return *this=*this*a;
    }
    inline cpx operator/=(const cpx &a){
        return *this=*this/a;
    }
    inline cpx conj(){
        return cpx(r,-i);
    }
};
template<class T,int len>
struct polynomial{
    T a[len];
    inline void clear(){
        int t=len>>2<<2,i;
        for(i=0;i<t;i+=4){
            a[i]=0;
            a[i+1]=0;
            a[i+2]=0;
            a[i+3]=0;
        }
        for(;i<len;i++)
            a[i]=0;
    }
    inline polynomial operator+(const polynomial &b)const{
        static polynomial c;
        int t=len>>2<<2,i;
        for(i=0;i<t;i+=4){
            c.a[i]=a[i]+b.a[i];
            c.a[i+1]=a[i+1]+b.a[i+1];
            c.a[i+2]=a[i+2]+b.a[i+2];
            c.a[i+3]=a[i+3]+b.a[i+3];
        }
        for(;i<len;i++)
            c.a[i]=a[i]+b.a[i];
        return c;
    }
    inline polynomial operator+=(const polynomial &b){
        return *this=*this+b;
    }
    inline polynomial operator-(const polynomial &b)const{
        static polynomial c;
        int t=len>>2<<2,i;
        for(i=0;i<t;i+=4){
            c.a[i]=a[i]-b.a[i];
            c.a[i+1]=a[i+1]-b.a[i+1];
            c.a[i+2]=a[i+2]-b.a[i+2];
            c.a[i+3]=a[i+3]-b.a[i+3];
        }
        for(;i<len;i++)
            c.a[i]=a[i]-b.a[i];
        return c;
    }
    inline polynomial operator-=(const polynomial &b){
        return *this=*this-b;
    }
    inline polynomial operator*(const polynomial &b){
        static polynomial ret;
        ret.clear();
        for(int i=0;i<len;i++)
            for(int j=0;j<=i;j++)
                ret.a[i]+=a[j]*b.a[i-j];
        return ret;
    }
    inline void Antiderivative(int c){
        int i;
        for(i=len-1;i;i--)
            a[i]=a[i-1]/i;
        a[0]=c;
    }
    inline T Get_val(T c){
        T ret(a[0]);
        for(int i=1;i<len;i++){
            ret+=c*a[i];
            c*=c;
        }
        return ret;
    }
};
void fft(cpx *a,int N,int f){
    int i,j=0,k,t;
    for(i=1;i<N-1;i++){
        for(t=N;j^=t>>=1,~j&t;);
        if(i<j)
            swap(a[i],a[j]);
    }
    for(i=1;i<N;i<<=1){
        cpx wn(cos(pi/i),f*sin(pi/i));
        t=i<<1;
        for(j=0;j<N;j+=t){
            cpx w(1,0);
            for(k=0;k<i;k++,w*=wn){
                cpx x(a[j+k]),y(w*a[j+k+i]);
                a[j+k]=x+y,a[j+k+i]=x-y;
            }
        }
    }
    if(f==-1)
        for(i=0;i<N;i++)
            a[i].r/=N;
}
void mul(cpx *a,cpx *b,cpx *c,cpx *t,int N){
    int i,j;
    for(i=0;i<N;i++)
        t[i]=cpx(a[i].r,b[i].r);
    fft(t,N,1);
    for(i=0;i<N;i++){
        j=(N-i)&(N-1);
        c[i]=(t[i]*t[i]-(t[j]*t[j]).conj())*cpx(0,-0.25);
    }
    fft(c,N,-1);
    // c refer t
    //a[i]=(c[i]+c[k-i])/2
    //b[i]=-i(c[i]-c[k-i])/2
    //a[i]*b[i]=(c[i]*c[i]-c[k-i]*c[k-i])*((-i)/4)
}
namespace mypq{
    template<class T,class Container=std::vector<T>,class cmp=std::less<typename Container::value_type> >
    struct priority_queue{
        std::priority_queue<T,Container,cmp>ins,del;
        inline void push(T a){
            ins.push(a);
        }
        inline void erase(T a){
            del.push(a);
        }
        inline void pop(){
            while(!del.empty()&&ins.top()==del.top())
                ins.pop(),del.pop();
            ins.pop();
        }
        inline T top(){
            while(!del.empty()&&ins.top()==del.top())
                ins.pop(),del.pop();
            return ins.top();
        }
        inline T second_top(){
            T tmp=top(),ret;
            pop();
            ret=top();
            push(tmp);
            return ret;
        }
        inline void clear(){
            while(!ins.empty())
                ins.pop();
            while(!del.empty())
                del.pop();
        }
        inline int size(){
            return ins.size()-del.size();
        }
        inline bool empty(){
            return !size();
        }
    };
}
void exgcd(long long a,long long b,long long &d,long long &x,long long &y){
    if(!b){
        d=a;
        x=1;
        y=0;
        return;
    }
    exgcd(b,a%b,d,y,x);
    y-=a/b*x;
}
//template
#define MAXN 200
#define EPS (1e-8)
int T;
int n,rx[MAXN*2+10],ry[MAXN*2+10],cx,cy;
int d[MAXN*2+10][MAXN*2+10],d2[MAXN*2+10][MAXN*2+10];
bool vis[MAXN*2+10][MAXN*2+10];
double dist[MAXN*2+10][MAXN*2+10];
struct rect{
    pii a,b;
}a[MAXN+10];
pii st,ed;
priority_queue<pair<double,pii>,vector<pair<double,pii> > ,greater<pair<double,pii> > >q;
void spfa(){
    int i,j;
    for(i=1;i<=cx;i++)
        for(j=1;j<=cy;j++)
            dist[i][j]=1e20;
    dist[st.first][st.second]=0;
    q.push({0,st});
    while(!q.empty()){
        pii u=q.top().second;
        q.pop();
        if(vis[u.first][u.second])
            continue;
        //
        vis[u.first][u.second]=1;
        pii t=u;
        t.first--;
        if(t.first>=1){
            if(dist[t.first][t.second]>dist[u.first][u.second]+1.0*(rx[u.first]-rx[t.first])/(d[t.first][t.second]+1)+EPS){
                dist[t.first][t.second]=dist[u.first][u.second]+1.0*(rx[u.first]-rx[t.first])/(d[t.first][t.second]+1);
                q.push({dist[t.first][t.second],t});
            }
        }
        //
        t=u;
        t.first++;
        if(t.first<=cx){
            if(dist[t.first][t.second]>dist[u.first][u.second]+1.0*(rx[t.first]-rx[u.first])/(d[u.first][u.second]+1)+EPS){
                dist[t.first][t.second]=dist[u.first][u.second]+1.0*(rx[t.first]-rx[u.first])/(d[u.first][u.second]+1);
                q.push({dist[t.first][t.second],t});
            }
        }
        //
        t=u;
        t.second--;
        if(t.second>=1){
            if(dist[t.first][t.second]>dist[u.first][u.second]+1.0*(ry[u.second]-ry[t.second])/(d2[t.first][t.second]+1)+EPS){
                dist[t.first][t.second]=dist[u.first][u.second]+1.0*(ry[u.second]-ry[t.second])/(d2[t.first][t.second]+1);
                q.push({dist[t.first][t.second],t});
            }
        }
        //
        t=u;
        t.second++;
        if(t.second<=cy){
            if(dist[t.first][t.second]>dist[u.first][u.second]+1.0*(ry[t.second]-ry[u.second])/(d2[u.first][u.second]+1)+EPS){
                dist[t.first][t.second]=dist[u.first][u.second]+1.0*(ry[t.second]-ry[u.second])/(d2[u.first][u.second]+1);
                q.push({dist[t.first][t.second],t});
            }
        }
    }
}
int main()
{
    Read(T);
    while(T--){
        memset(d,0,sizeof d);
        memset(d2,0,sizeof d2);
        memset(vis,0,sizeof vis);
        cx=cy=0;
        Read(n);
        int i,j;
        for(i=1;i<=n;i++){
            Read(a[i].a.first),Read(a[i].a.second);
            Read(a[i].b.first),Read(a[i].b.second);
            rx[++cx]=a[i].a.first,ry[++cy]=a[i].a.second;
            rx[++cx]=a[i].b.first,ry[++cy]=a[i].b.second;
        }
        Read(st.first),Read(st.second);
        Read(ed.first),Read(ed.second);
        rx[++cx]=st.first,ry[++cy]=st.second;;
        rx[++cx]=ed.first,ry[++cy]=ed.second;
        sort(rx+1,rx+cx+1);
        sort(ry+1,ry+cy+1);
        cx=unique(rx+1,rx+cx+1)-rx-1;
        cy=unique(ry+1,ry+cy+1)-ry-1;
        for(i=1;i<=n;i++){
            a[i].a.first=lower_bound(rx+1,rx+cx+1,a[i].a.first)-rx;
            a[i].a.second=lower_bound(ry+1,ry+cy+1,a[i].a.second)-ry;
            a[i].b.first=lower_bound(rx+1,rx+cx+1,a[i].b.first)-rx;
            a[i].b.second=lower_bound(ry+1,ry+cy+1,a[i].b.second)-ry;
            d[a[i].a.first][a[i].a.second]++;
            d[a[i].b.first][a[i].a.second]--;
            d[a[i].a.first][a[i].b.second+1]--;
            d[a[i].b.first][a[i].b.second+1]++;
            d2[a[i].a.first][a[i].a.second]++;
            d2[a[i].b.first+1][a[i].a.second]--;
            d2[a[i].a.first][a[i].b.second]--;
            d2[a[i].b.first+1][a[i].b.second]++;
        }
        st.first=lower_bound(rx+1,rx+cx+1,st.first)-rx;
        st.second=lower_bound(ry+1,ry+cy+1,st.second)-ry;
        ed.first=lower_bound(rx+1,rx+cx+1,ed.first)-rx;
        ed.second=lower_bound(ry+1,ry+cy+1,ed.second)-ry;
        for(i=1;i<=cx;i++)
            for(j=1;j<=cy;j++){
                d[i][j]+=d[i-1][j]+d[i][j-1]-d[i-1][j-1];
                d2[i][j]+=d2[i-1][j]+d2[i][j-1]-d2[i-1][j-1];
            }
        spfa();
        printf("%.5lf\n",dist[ed.first][ed.second]);
    }
}