#include<bits/stdc++.h>
using namespace std;
using ld=double;
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(!isdigit(ch))
	{
        if(ch=='-')f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
	{
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
inline ld readld()
{
    int x1=0,x2=0,t=1,k=1;
	bool f=1;
    char ch=getchar();
    while(!isdigit(ch))
	{
        if(ch=='-')k=-1;
        ch=getchar();
    }
    while(isdigit(ch)||ch=='.')
    {
        if(ch=='.'){f=0,ch=getchar();continue;}
        if(f)x1=(x1<<1)+(x1<<3)+(ch&15);
        else x2=(x2<<1)+(x2<<3)+(ch&15),t=(t<<1)+(t<<3);
        ch=getchar();
    }
    return k*(x1+(ld)x2/(ld)t);
}
inline void write(int x)
{
    if(x<0)
	{
        putchar('-');
        x=-x;
    }
    if(x>9)write(x/10);
    putchar(x%10+48);
    return;
}
namespace Polygon
{
	const ld eps=1e-10,INF=1e10;
	const int M=1e5+5;
	int equal(ld x)
	{
		if(fabs(x)<eps)return 0;
		return x<0?-1:1;
	}
	struct Point
	{
		ld x,y;int id;
		Point(ld _x=0,ld _y=0,int _id=0){x=_x,y=_y,id=_id;}
		inline void input(){x=readld(),y=readld();}
	};
	typedef Point Vector;
	typedef vector<Point> VecP;
	typedef vector<Vector> VecV;
	Vector operator+(Vector A,Vector B){return Vector(A.x+B.x,A.y+B.y);}
	Vector operator-(Vector A,Vector B){return Vector(A.x-B.x,A.y-B.y);}
	Vector operator*(Vector A,ld p){return Vector(A.x*p,A.y*p);}
	Vector operator/(Vector A,ld p){return Vector(A.x/p,A.y/p);}
	bool operator<(const Vector&A,const Vector&B){return A.x<B.x||(A.x==B.x&&A.y<B.y);}
	bool operator==(const Vector&A,const Vector&B){return !(equal(A.x-B.x)||equal(A.y-B.y));}
	ld Dot(Vector A,Vector B){return A.x*B.x+A.y*B.y;}
	ld Module(Vector A){return sqrt(A.x*A.x+A.y*A.y);}
	ld Dist(Point A,Point B){return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));}
	ld Dist2(Point A,Point B){return (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);}
	ld Angle(Vector A,Vector B){return acos(Dot(A,B)/(Module(A)*Module(B)));}
	ld Cross(Vector A,Vector B){return A.x*B.y-A.y*B.x;}
	ld Area(Vector A,Vector B,Vector C){return Cross(B-A,C-A)/2;}
	Vector Projection(Vector A,Vector B){return B*(Dot(A,B)/(Module(B)*Module(B)));}
	Vector Rotate(Vector A,ld rad){return Vector(A.x*cos(rad)-A.y*sin(rad),A.x*sin(rad)+A.y*cos(rad));}
	bool VectorParallel(Vector A,Vector B){return !equal(Cross(A,B));}
	Vector GetDirect(Point A,Point B){return Vector(B.x-A.x,B.y-A.y);}
	ld Link(Point A,Point B,Point P){return Cross(GetDirect(A,B),GetDirect(A,P));}
	Vector Normal(Vector A)
	{
		ld Mod=Module(A);
		return Vector(-A.y/Mod,A.x/Mod);
	}
	struct Line
	{
		Point P;
		Vector V;
		Line(Point p=Point(),Vector v=Point()){P=p,V=v;}
		bool operator==(const Line&B)const{return !equal(Cross(V,B.V))&&!equal(Cross(V,B.P-P));}
	};
	typedef vector<Line> VecL;
	VecL::iterator operator+(VecL l,int pos){return l.begin()+pos;}
	struct Segment
	{
		Point A,B;ld Angle;int id;
		Segment(Point a=Point(),Point b=Point(),int _id=0){A=a,B=b,id=_id,Angle=atan2((b-a).y,(b-a).x);}
		bool operator<(const Segment&S)const
		{
			if(!equal(Angle-S.Angle))return Link(A,S.A,S.B)>0;
			return Angle<S.Angle;
		}
	};
	typedef vector<Segment> VecS;
	VecS::iterator operator+(VecS s,int pos){return s.begin()+pos;}
	bool SegmentProperIntersection(Segment s1,Segment s2)
	{
		bool fg=1;
		fg&=max(s1.A.x,s1.B.x)>=min(s2.A.x,s2.B.x); 
		fg&=max(s1.A.y,s1.B.y)>=min(s2.A.y,s2.B.y); 
		fg&=max(s2.A.x,s2.B.x)>=min(s1.A.x,s1.B.x); 
		fg&=max(s2.A.y,s2.B.y)>=min(s1.A.y,s1.B.y); 
		ld t1=Cross((s1.B-s1.A),(s2.A-s1.A)),t2=Cross((s1.B-s1.A),(s2.B-s1.A));
		ld t3=Cross((s2.B-s2.A),(s1.A-s2.A)),t4=Cross((s2.B-s2.A),(s1.B-s2.A));
		return fg&&equal(t1)*equal(t2)<=0&&equal(t3)*equal(t4)<=0;
	}
	bool LineParallel(Line l1,Line l2){return VectorParallel(l1.V,l2.V);}
	Point GetSegIntersection(Segment s1,Segment s2)
	{
		ld t1=Link(s1.A,s2.B,s1.B),t2=Link(s1.A,s2.A,s1.B);
		return Point((t1*s2.A.x-t2*s2.B.x)/(t1-t2),(t1*s2.A.y-t2*s2.B.y)/(t1-t2));
	}
	Point GetLineIntersection(Line l1,Line l2)
	{
		Vector tv=l1.P-l2.P;
		ld tp=Cross(l2.V,tv)/Cross(l1.V,l2.V);
		return l1.P+l1.V*tp;
	}
	ld GetPointLineDist(Point P,Line l)
	{
		Vector tv=P-l.P;
		return fabs(Cross(tv,l.V))/Module(l.V);
	}
	ld GetPointSegDist(Point P,Segment l)
	{
		if(l.A==l.B)return Module(P-l.A);
		Vector u=l.B-l.A,v=P-l.A,w=P-l.B;
		if(equal(Dot(u,v))<0)return Module(v);
		if(equal(Dot(u,w))>0)return Module(w);
		return fabs(Cross(u,v))/Module(u);
	}
	Point GetLineProjection(Point P,Line l)
	{
		Vector tv=P-l.P;
		return l.P+l.V*(Dot(l.V,P-l.P)/Module(l.V));
	}
	bool OnSegment(Point P,Segment s){return equal(Cross(s.A-P,s.B-P))==0&&equal(Dot(s.A-P,s.B-P))<0;}
	bool OnRightSegment(Point P,Segment s){equal(Cross(P-s.A,s.B))>0;}
	ld PolygonArea(int n,vector<Point>p)
	{
		ld S=0;
		for(int i=2;i<n;++i)S+=(Cross(p[i]-p[1],p[i+1]-p[1])/2.0);
		return S;
	}
	inline int Andrew(int n,VecP p,VecP&stk)
	{
	    sort(p.begin()+1,p.begin()+n+1);
	    if(n<3)return -1;
	    stk[1]=p[1],stk[2]=p[2];
	    int top=2;
	    for(int i=3;i<=n;++i)
		{
	        while(top>1&&Link(stk[top-1],stk[top],p[i])<=0)--top;
	        stk[++top]=p[i];
	    }
	    stk[++top]=p[n-1];
	    for(int i=n-2;i;--i)
		{
	        while(top>1&&Link(stk[top-1],stk[top],p[i])<=0)--top;
	        stk[++top]=p[i];
	    }
	    return top;
	}
	inline int Graham(int n,VecP p,VecP&stk)
	{
		auto Graham_cmp=[&](Point S,Point B)
		{
			if(S.x==B.x&&S.y==B.y)return false;
			ld Jd=Cross(GetDirect(p[1],S),GetDirect(p[1],B));
			if(Jd>0)return true;
			return !Jd&&Dist(p[0],S)<=Dist(p[0],B);
		};
		sort(p.begin()+2,p.begin()+n+1,Graham_cmp);
		stk[1]=p[1];
		int top=1;
		for(int i=2;i<=n;++i)
		{
			while(top>1&&Link(stk[top-1],stk[top],p[i])<=0)--top;
			stk[++top]=p[i];
		}
		stk[top+1]=p[1]; 
		return top;
	}
	inline ld HalfPlane(int n,VecS s)
	{
		sort(s.begin()+1,s.begin()+n+1);
		n=unique(s.begin()+1,s.begin()+n+1,[&](Segment S1,Segment S2){return fabs(S1.Angle-S2.Angle)<=eps;})-s.begin()-1;
		VecS st(n+1);
		st[1]=s[1],st[2]=s[2];
		int hd=1,tl=2;
		for(int i=3;i<=n;++i)
		{
			while(hd<tl&&Link(GetSegIntersection(st[tl],st[tl-1]),s[i].A,s[i].B)<0)--tl;
			while(hd<tl&&Link(GetSegIntersection(st[hd],st[hd+1]),s[i].A,s[i].B)<0)++hd;
			st[++tl]=s[i];
		}
		while(hd<tl&&Link(GetSegIntersection(st[tl],st[tl-1]),st[hd].A,st[hd].B)<0)--tl;
		while(hd<tl&&Link(GetSegIntersection(st[hd],st[hd+1]),st[tl].A,st[tl].B)<0)++hd;
		int m=tl-hd+1;
		VecP p(m+1);
		for(int i=hd;i<tl;++i)p[i-hd+1]=GetSegIntersection(st[i],st[i+1]);
		if(tl-hd>1)p[tl-hd+1]=GetSegIntersection(st[hd],st[tl]);
		return PolygonArea(m,p);
	}
}
using namespace Polygon;
struct edges
{
	int to,nxt,val;
}edge[M<<1];
int hd[M],tot=0;
inline void addedge(int u,int v)
{
	edge[++tot].nxt=hd[u];
	edge[tot].to=v;
	edge[tot].val=1;
	hd[u]=tot;
	return;
}
inline void HalfPlane_suibian_Version(int n,VecS s,int id)
{
	sort(s.begin()+1,s.begin()+n+1);
	n=unique(s.begin()+1,s.begin()+n+1,[&](Segment S1,Segment S2){return fabs(S1.Angle-S2.Angle)<=eps;})-s.begin()-1;
	VecS st(n+1);
	st[1]=s[1],st[2]=s[2];
	int hd=1,tl=2;
	for(int i=3;i<=n;++i)
	{
		while(hd<tl&&Link(GetSegIntersection(st[tl],st[tl-1]),s[i].A,s[i].B)<0)--tl;
		while(hd<tl&&Link(GetSegIntersection(st[hd],st[hd+1]),s[i].A,s[i].B)<0)++hd;
		st[++tl]=s[i];
	}
	while(hd<tl&&Link(GetSegIntersection(st[tl],st[tl-1]),st[hd].A,st[hd].B)<0)--tl;
	while(hd<tl&&Link(GetSegIntersection(st[hd],st[hd+1]),st[tl].A,st[tl].B)<0)++hd;
	if(tl-hd<=1)return;
	for(int i=hd;i<=tl;++i)
	{
		addedge(id,st[i].id);
		addedge(st[i].id,id);
	}
	return;
}
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>q;
bool vis[M];
int dis[M];
inline int Dijkstra(int s,int t)
{
	for(int i=0;i<=t+1;++i)dis[i]=0x3f3f3f3f,vis[i]=0;
	dis[s]=0;
	q.push({0,s});
    while(!q.empty())
    {
        int top=q.top().second;
		q.pop();
        if(vis[top])continue;
        vis[top]=1;
        for(int i=hd[top];i;i=edge[i].nxt)
        {
        	int to=edge[i].to,val=edge[i].val;
            if(dis[to]>dis[top]+val)
            {
                dis[to]=dis[top]+val;
                if(!vis[to])q.push({dis[to],to});
            }
        }
    }
    return dis[t];
}
VecS s(M);
VecP p(M);
Point Ed,Young;
vector<bool>notEd(M);
inline Segment addline(ld A,ld B,ld C,int id){return Segment(Point(-C/(A*A+B*B)*A,-C/(A*A+B*B)*B),Point(B-C/(A*A+B*B)*A,-C/(A*A+B*B)*B-A),id);} 
int main()
{
	int T=read();
	while(T--)
	{
		int n=read();
		Ed.input(),Young.input();
		if(!n){puts("0");continue;}
		ld Dis=INF;
		int id=0;
		for(int i=1;i<=n;++i)
		{
			p[i].input();
			if(p[i].x>Ed.x||p[i].y>Ed.y){notEd[i]=1;continue;}
			ld t=Dist2(p[i],Young);
			if(t<Dis)Dis=t,id=i;
		}
		for(int i=1;i<=n;++i)
		{
			if(notEd[i])continue;
			int cnt=0;
		    s[++cnt]=addline(0,-1,Ed.y,n+1);
		    s[++cnt]=addline(0,1,0,n+1);
		    s[++cnt]=addline(1,0,0,n+1);
		    s[++cnt]=addline(-1,0,Ed.x,n+1);
		    for(int j=1;j<=n;++j)
		    {
		    	if(j==i||notEd[j])continue;
		    	ld A=2*(p[i].x-p[j].x),B=2*(p[i].y-p[j].y),C=p[j].x*p[j].x+p[j].y*p[j].y-p[i].x*p[i].x-p[i].y*p[i].y;
		    	s[++cnt]=addline(A,B,C,j);
			}
			HalfPlane_suibian_Version(cnt,s,i);
		}
		write(Dijkstra(id,n+1)),puts("");
		for(int i=1;i<M;++i)edge[i]={0,0,0},hd[i]=0,notEd[i]=0;
	}
    return 0;
}
//(2*x1-2*xi)*x+(2*y1-2*yi)*y+(xi*xi+yi*yi-x1*x1-y1*y1)>=0;