#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
using namespace std;

typedef long double db;

const int MAXN=205;
const db maxc=2e2;
const db inf=1e20;
const db eps=1e-9;

int sgn(db x)
{
    if(x>eps)return 1;
    if(x<-eps)return -1;
    return 0;
}

struct Point
{
    db x,y;
    Point(){}
    Point(db _x,db _y):x(_x),y(_y){}
    Point operator + (const Point& t)const { return Point(x+t.x,y+t.y); }
    Point operator - (const Point& t)const { return Point(x-t.x,y-t.y); }
    Point operator * (const db& t)const { return Point(x*t,y*t); }
    Point operator / (const db& t)const { return Point(x/t,y/t); }
    db operator * (const Point& t)const { return x*t.y-y*t.x; }
    db operator ^ (const Point& t)const { return x*t.x+y*t.y; }
    bool operator < (const Point& t)const { return sgn(x-t.x)==0 ? y<t.y : x<t.x; }
    bool operator == (const Point& t)const { return sgn(x-t.x)==0 && sgn(y-t.y)==0; }
    db len()const { return sqrt(x*x+y*y); }
};

struct Line
{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e):s(_s),e(_e){}
    Point reflect(const Point& s)const
    {
        return get_point(get_ratio(s))*2-s;
    }
    vector<Point> operator & (const Line& t)const
    {
        if(sgn((e-s)*(t.e-t.s))==0)return {};
        return {s+(e-s)*(((t.s-s)*(t.e-t.s))/((e-s)*(t.e-t.s)))};
    }
    db get_ratio(const Point& t)const
    {
        return ((t-s)^(e-s))/(e-s).len()/(e-s).len();
    }
    Point get_point(const db& r)const
    {
        return s+(e-s)*r;
    }
};

bool segment_strict_intersect(const Line& a,const Line& b)
{
    return sgn((b.s-a.s)*(a.e-a.s))*sgn((b.e-a.s)*(a.e-a.s))<0
        && sgn((a.s-b.s)*(b.e-b.s))*sgn((a.e-b.s)*(b.e-b.s))<0;
}
bool point_in_segment(const Point& p,const Line& t)
{
    return sgn((p-t.s)*(p-t.e))==0 && sgn((p-t.s)^(p-t.e))<=0;
}
int point_in_polygon(const Point& p,const vector<Point>& poly)
{
    Line l=Line(p,Point(maxc,p.y));
    int cnt=0;
    for(size_t i=0;i<poly.size();i++)
    {
        Line t=Line(poly[i],poly[(i+1)%poly.size()]);
        if(point_in_segment(p,t))return 0;
        if(segment_strict_intersect(l,t))cnt++;
        else if(sgn(t.s.y-t.e.y))
        {
            if(sgn(t.s.y-t.e.y)>0)swap(t.s,t.e);
            if(sgn(t.s.y-p.y)==0 && sgn(t.s.x-p.x)>=0)cnt++;
        }
    }
    return (cnt%2==0 ? 1 : -1);
}
bool segment_intersect_polygon(const Line& l,const vector<Point>& poly)
{
    for(size_t i=0;i<poly.size();i++)
        if(segment_strict_intersect(l,Line(poly[i],poly[(i+1)%poly.size()])))return 1;
    vector<Point> cut{l.s,l.e};
    for(size_t i=0; i<poly.size(); i++)
        if(point_in_segment(poly[i],l))
            cut.push_back(poly[i]);
    sort(cut.begin(),cut.end(),[&](const Point& a, const Point& b) {
        return ((a-b)^(l.e-l.s))<0;
    });
    cut.erase(unique(cut.begin(),cut.end()),cut.end());
    for(size_t i=0; i+1<cut.size(); i++)
        if(point_in_polygon((cut[i]+cut[i+1])/2, poly)<0)return 1;
    return 0;
}

bool visible(const Point& p,const Point& t,const Line& mr,const vector<Point>& poly)
{
    // never move along mirror
    if(point_in_segment(p,mr))return 0;
    // see target straightly
    if(!segment_strict_intersect(Line(p,t),mr) && !segment_intersect_polygon(Line(p,t),poly))return 1;
    // see target through mirror
    if(sgn((p-mr.s)*(mr.e-mr.s))<=0 || sgn((t-mr.s)*(mr.e-mr.s))<=0)return 0;
    auto inter=Line(p,mr.reflect(t))&mr;
    if(inter.empty())return 0;
    Point m=inter.front();
    if(!point_in_segment(m,mr))return 0;
    if(segment_intersect_polygon(Line(p,m),poly))return 0;
    if(segment_intersect_polygon(Line(m,t),poly))return 0;
    return 1;
}
bool visible(const Line& l,const Point& t,const Line& mr,const vector<Point>& poly,const vector<Line>& border)
{
    vector<Point> cut{l.s,l.e};
    for(auto& b : border)
        for(auto& p : l&b)
            if(point_in_segment(p,l))
                cut.push_back(p);
    sort(cut.begin(),cut.end(),[&](const Point& a, const Point& b) {
        return ((a-b)^(l.e-l.s))<0;
    });
    cut.erase(unique(cut.begin(),cut.end()),cut.end());
    for(size_t i=0;i+1<cut.size();i++)
        if(!visible((cut[i]+cut[i+1])/2, t, mr, poly))return 0;
    return 1;
}

db len[MAXN][MAXN];
int ty[MAXN][MAXN];
int build(const Point& s,const Point& t,const Line& mr,const vector<Point>& poly)
{
    Point rs=mr.reflect(s),rt=mr.reflect(t);
    vector<Line> border;
//    border.push_back(mr);
//    for(size_t i=0;i<poly.size();i++)
//        border.emplace_back(poly[i],poly[(i+1)%poly.size()]);
    for(auto& p : poly)
    {
        border.emplace_back(p,s);
        border.emplace_back(p,t);
        border.emplace_back(p,rs);
        border.emplace_back(p,rt);
    }
    border.emplace_back(s,mr.s);
    border.emplace_back(s,mr.e);
    border.emplace_back(t,mr.s);
    border.emplace_back(t,mr.e);
    border.emplace_back(rs,mr.s);
    border.emplace_back(rs,mr.e);
    border.emplace_back(rt,mr.s);
    border.emplace_back(rt,mr.e);
    vector<Point> keys;
    keys.push_back(s);
    keys.push_back(t);
//    keys.push_back(mr.s);
//    keys.push_back(mr.e);
//    for(auto& p : poly)
//        keys.push_back(p);
    for(size_t i=0;i<border.size();i++)
        for(size_t j=i+1;j<border.size();j++)
            for(auto& p : border[i]&border[j])
                if(find(keys.begin(),keys.end(),p)==keys.end())
                    keys.push_back(p);
    int n=keys.size();
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
        {
            Line l=Line(keys[i],keys[j]);
            if(segment_strict_intersect(l,mr) || segment_intersect_polygon(l,poly))
            {
                len[i][j]=len[j][i]=inf;
                continue;
            }
            int c=visible(l,s,mr,poly,border);
            c|=visible(l,t,mr,poly,border)<<1;
            ty[i][j]=ty[j][i]=c;
            len[i][j]=len[j][i]=(keys[i]-keys[j]).len();
        }
    return n;
}

db dis[MAXN];
bool vis[MAXN];
db cal(int n,int c)
{
    for(int i=0;i<n;i++)
        dis[i]=inf,vis[i]=0;
    dis[0]=0;
    for(int _=0;_<n;_++)
    {
        int u=-1;
        for(int i=0;i<n;i++)
        {
            if(vis[i] || dis[i]==inf)continue;
            if(u==-1 || dis[i]<dis[u])u=i;
        }
        if(u<0)break;
        vis[u]=1;
        for(int v=0;v<n;v++)
        {
            if(vis[v] || (ty[u][v]&c)!=c)continue;
            dis[v]=min(dis[v],dis[u]+len[u][v]);
        }
    }
    return dis[1];
}

int solve()
{
    int m;
    scanf("%d",&m);
    Point s,t;
    scanf("%Lf%Lf%Lf%Lf",&s.x,&s.y,&t.x,&t.y);
    Line mr;
    scanf("%Lf%Lf%Lf%Lf",&mr.s.x,&mr.s.y,&mr.e.x,&mr.e.y);
    vector<Point> poly;
    for(int i=0;i<3;i++)
    {
        db x,y;
        scanf("%Lf%Lf",&x,&y);
        poly.emplace_back(x,y);
    }
    int n=build(s,t,mr,poly);
    db res=0;
    if(m==1)res=cal(n,0);
    else res=cal(n,1)+cal(n,2)+(2*m-3)*cal(n,3);
    if(res<inf)printf("%.12Lf\n",res);
    else printf("-1\n");
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)solve();
    return 0;
}