#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <algorithm>
#include <complex>
#include <iterator>
#include <cassert>

using namespace std;
typedef complex<long long> xy;
typedef vector<xy> xys;
typedef vector<int> array;

const int infty=1<<29;

namespace std{
    template<typename T_>
    basic_ostream<char,T_> &operator<<(basic_ostream<char,T_>& out,const xy&p){
        return out<<p.real()<<" "<<p.imag();
    }
};

long long inner_product(const xy &p, const xy &q) { return real(conj(p)*q); }
long long outer_product(const xy &p, const xy &q) { return imag(conj(p)*q); }
int ccw(xy p, xy q, xy r){
    r-=p;
    q-=p;
    long long op=outer_product(q,r);
    if ( op>0 ) return 1;
    if ( op<0 ) return -1;
    if ( inner_product(q,r)<0 ) return -2;
    if ( norm(q)<norm(r) ) return +2;
    return 0;
}

bool cross_lines(const xy &p1, const xy &p2,
                 const xy &q1, const xy &q2){
    return ccw(p1,p2,q1)*ccw(p1,p2,q2)<=0 &&
        ccw(q1,q2,p1)*ccw(q1,q2,p2)<=0;
}
bool overlapped(const xy &p1, const xy &p2,
                const xy &q1, const xy &q2){
    return cross_lines(p1,p2,q1,q2);
}

long long len(const xy &p) {
    return static_cast<int>(sqrt(static_cast<double>(norm(p))));
}

xy normalize(const xy &p) {
    return p/len(p);
}

xys make_dir(const xys &vert){
    xys dir;
    for ( unsigned int i=1 ; i<vert.size() ; ++i )
        dir.push_back(normalize(vert[i]-vert[i-1])*xy(0,1));
    return dir;
}
int height(xys &vert);
int dissolve_overlap_and_height(const xys &vert0){
    xys vert(vert0);
    vert.pop_back();
    assert(vert.size()%2==0);
    /*
    cout<<"into:";
    copy(vert.begin(),vert.end(),
         ostream_iterator<xy>(cout,"\n"));
    cout<<endl;
    /   */
    bool endo=false;
    while(!endo){
        endo=true;
        for ( unsigned i=0 ; i+1<vert.size() ; ++i ) {
            if ( vert[i]!=vert[i+1] )
                continue;
            vert.erase(vert.begin()+i,vert.begin()+i+2);
            endo=false;
            break;
        }
        if ( !vert.empty()&&vert.back()==vert.front() ) {
            vert.pop_back();
            vert.erase(vert.begin());
        }
    }
    if ( vert.empty() )
        return 0;
    vert.push_back(vert.front());
    xys dir(make_dir(vert));
    /*
    cout<<"and :";
    copy(vert.begin(),vert.end(),
         ostream_iterator<xy>(cout,"\n"));
    cout<<endl;
    cout<<"dir :";
    copy(dir.begin(),dir.end(),
         ostream_iterator<xy>(cout,"\n"));
    cout<<endl;
    /   */
    const unsigned int n=dir.size();
    assert(n%2==0);
    for ( unsigned int i=0 ; i<n ; ++i ) {
        for ( unsigned int j=i+1 ; j<n ; ++j ) {
            if ( dir[i]+dir[j]!=xy(0,0) )
                continue;
            
            if ( real((vert[j]-vert[i])/dir[i]) !=0 )
                continue;
            if ( !overlapped(vert[i],vert[i+1],vert[j],vert[j+1]))
                continue;
            assert(((i+j)&1)==0);
            //cout<<"match "<<i<<" "<<j<<" "<<n<<endl;
            xys vert2;
            if ( vert[i+1]==vert[j] ) {
                if ( dir[(i+1)%n]==dir[(j-1)%n] )
                    ; //__||__ meaningless vertex
                else
                    // _| meaningful vertex
                    //  |~
                    assert(false);//vert2.push_back(vert[i+1]);
            }
            else
                vert2.push_back(vert[i+1]);
            for ( unsigned int k=i+2 ; k<j ; ++k )
                vert2.push_back(vert[k]);
            if ( vert[i+1]!=vert[j] )
                vert2.push_back(vert[j]);
            vert2.push_back(vert2.front());
            assert(vert2.size()%2==1);
            //cout<<"here"<<endl;
            xys vert3;
            if ( vert[j+1]==vert[i] ) {
                if ( dir[(j+1)%n]==dir[(i-1+n)%n] )
                    ; //__||__ meaningless vertex
                else//_| meaningful vertex
                    // |~
                    assert(false);//vert3.push_back(vert[j+1]);
            }
            else
                vert3.push_back(vert[j+1]);
            for ( unsigned int k=j+2 ; k<n ; ++k )
                vert3.push_back(vert[k]);
            for ( unsigned int k=j+1==n?1:0 ; k<i ; ++k )
                vert3.push_back(vert[k]);
            if ( vert[j+1]!=vert[i] )
                vert3.push_back(vert[i]);
            vert3.push_back(vert3.front());
            assert(vert3.size()%2==1);
            return max(dissolve_overlap_and_height(vert2),
                       dissolve_overlap_and_height(vert3));
        }
    }
    //nothing
    xys vertn(vert);
    return height(vertn);
}
int height(xys &vert){
    /*
    cout<<"next:";
    copy(vert.begin(),vert.end(),
         ostream_iterator<xy>(cout,"\n"));
    cout<<endl;
    /   */
    if ( vert.size()<5 ) return 0;
    if ( vert.size()==5 ) {
        return min(len(vert[0]-vert[1])/2, len(vert[1]-vert[2])/2);
    }
    assert(vert.size()%2==1);
    xys dir(make_dir(vert));
    xys v_dir;
    v_dir.push_back(dir.back()+dir.front());
    for ( unsigned int i=1 ; i<vert.size()-1 ; ++i )
        v_dir.push_back(dir[i-1]+dir[i]);
    v_dir.push_back(v_dir.front());
    {
        long long j=0;
        for ( int i=0 ; i<dir.size() ; ++i ) {
            long long k=imag(dir[i]/dir[(i+dir.size()-1)%dir.size()]);
            assert(k==1 or k==-1);
            j+=k;
        }
        assert(j==4);
    }
    long long res=infty;
    for ( unsigned int i=0 ; i<dir.size() ; ++i ) {
        for ( unsigned int j=i+1 ; j<dir.size() ; ++j ) {
            if ( dir[i]+dir[j]!=xy(0,0) )
                continue;
            long long distance = real((vert[j]-vert[i])/dir[i])/2;
            //cout<<"("<<i<<","<<j<<"):d="<<distance<<endl;
            if ( distance<0 )
                    distance=infty;
            else if ( !overlapped(vert[i]+distance*v_dir[i],
                                  vert[i+1]+distance*v_dir[i+1],
                                  vert[j]+distance*v_dir[j],
                                  vert[j+1]+distance*v_dir[j+1]) )
                distance=infty;
            //if ( distance<infty )
            //    cout<<"("<<i<<","<<j<<"):d="<<distance<<endl;
            res=min(res,distance);
        }
    }
    // move toward inside
    for ( unsigned int i=0 ; i<vert.size() ; ++i )
        vert[i]+=res*v_dir[i];
    
    // dissolve overlap
    return res+dissolve_overlap_and_height(vert);
}

int main(void)
{
    int nc;
    cout.setf(ios::fixed);
    cout<<setprecision(1);
    cin>>nc;
    while ( --nc>=0 ) {
        int nv;
        cin>>nv;
        xys vs;
        for ( int i=0 ; i<nv ; ++i ) {
            int cx, cy;
            cin>>cx>>cy;
            vs.push_back(xy(cx*2,cy*2));
        }
        vs.push_back(vs.front());
        cout<<height(vs)*0.5<<endl;
    }
    return 0;
}