//Square.cc - revised version
//ECNA 2012

#include<iostream>
#include <math.h>
#include <cstdio>
using namespace std;

const bool DEBUG=false;

#define IFDB if (DEBUG)
#define FOR(i,n) for (int i=0;i<n;i++)

struct point{
  int x, y;
};

point P[4];          //coords of the 4 points
point v1, v2, v3;    //vectors of opposite points

struct Slope{
  double x,y;
};

//*****
void PrintPts(){
  FOR(i,4) cout<<P[i].x<<","<<P[i].y<<" ";
  cout<<endl;
}

//*****
double myabs(double a){
  if (a>=0) return a;
  else return -1.0*a;
}

bool IsEq(double a, double b){  // equal func for doubles
  return myabs(a-b) < 0.0001;
}

//*****

//true if any 3 of P[] are colinear
bool IsColinear(){
  int rise1, run1, rise2, run2;

  //1st check P0, P1, P2
  rise1 = P[1].y - P[0].y; run1 = P[1].x - P[0].x;
  rise2 = P[2].y - P[0].y; run2 = P[2].x - P[0].x;
  //see if slopes equal
  if(rise1*run2 == rise2*run1) return true;
 
  //now P0, P1, P3
  rise2 = P[3].y - P[0].y; run2 = P[3].x - P[0].x;
  //see if slopes equal
  if(rise1*run2 == rise2*run1) return true;

  //now P0, P2, P3
  rise1 = P[3].y - P[0].y; run1 = P[3].x - P[0].x;
  rise2 = P[2].y - P[0].y; run2 = P[2].x - P[0].x;
  //see if slopes equal
  if(rise1*run2 == rise2*run1) return true;
 
  //now P1, P2, P3
  rise1 = P[3].y - P[1].y; run1 = P[3].x - P[1].x;
  rise2 = P[2].y - P[1].y; run2 = P[2].x - P[1].x;
  //see if slopes equal
  if(rise1*run2 == rise2*run1) return true;

  return false;         //no colinear
}
//*****


//crude sort for points - get them in cc order
void SortPts(){
  point temp, temp1, temp2, temp3;
  double cos1, cos2, cos3;
  int a,b;

  for(int i=3;i>0;i--)
    if (P[i].y<P[i-1].y){
      temp=P[i-1]; P[i-1]=P[i]; P[i]=temp;
    }
    else
      if (P[i].y==P[i-1].y && P[i].x<P[i-1].x){
        temp=P[i-1]; P[i-1]=P[i]; P[i]=temp;
    }
   //P[0] is now lowest (leftmost) point
   //compute dot products
   a = P[1].x-P[0].x; b=P[1].y-P[0].y;
   cos1=a/sqrt(1.0*a*a+b*b);
   a = P[2].x-P[0].x; b=P[2].y-P[0].y;
   cos2=a/sqrt(1.0*a*a+b*b);
   a = P[3].x-P[0].x; b=P[3].y-P[0].y;
   cos3=a/sqrt(1.0*a*a+b*b);
//IFDB cout<<cos1<<" "<<cos2<<" "<<cos3<<endl;
   if(cos1>cos2 && cos1>cos3){     //P[1] next
     temp1=P[1];
     if(cos2>cos3) {
       temp2=P[2]; temp3=P[3];    // ..., P2, P3
     }
     else {
        temp2=P[3]; temp3=P[2];   // ..,P3, P2
     }
   }
   if(cos2>cos1 && cos2>cos3){     //P[2] next
     temp1=P[2];
     if(cos1>cos3) {
       temp2=P[1]; temp3=P[3];
     }
     else {
        temp2=P[3]; temp3=P[1];
     }
   }
   if(cos3>cos2 && cos3>cos1){     //P[3] next
     temp1=P[3];
     if(cos2>cos1) {
       temp2=P[2]; temp3=P[1];
     }
     else {
        temp2=P[1]; temp3=P[2];
     }
   }
   P[1]=temp1; P[2]=temp2; P[3]=temp3;
}
 
//*****

void PrintVectors(){
  cout<<"vectors p2-p0 and p3-p1: "<<v1.x<<","<<v1.y<<" "<<v2.x<<","<<v2.y<<endl;
}

//*****

//distance between Pa and Pb
double dist(int a, int b){
  return sqrt((P[a].x-P[b].x)*(P[a].x-P[b].x)+(P[a].y-P[b].y)*(P[a].y-P[b].y));
}

//*****

//see if side with slope m thru P[a]
//is "outside" P[b]-P[a] and P[c]-P[a]
// can happen if the square is too small (some points lie outside square)
//if this is smaller than the area of square, sol is degenerate
bool IsDegenerate(double A, double m){
  double side=sqrt(A), altside;
  point v;

  //see that side > dist from P0 side (slope==m) to P1
  v.x = P[1].x-P[0].x; v.y = P[1].y-P[0].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P0 side (slope==m) to parallel side thru P3
  v.x = P[3].x-P[0].x; v.y = P[3].y-P[0].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P2 side (slope==m) to parallel side thru P1
  v.x = P[1].x-P[2].x; v.y = P[1].y-P[2].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P2 side (slope==m) to parallel side thru P3
  v.x = P[3].x-P[2].x; v.y = P[3].y-P[2].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  m = -1.0/m;
  //see that side > length from P1 side (slope==m) to parallel side thru P0
  v.x = P[0].x-P[1].x; v.y = P[0].y-P[1].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P1 side (slope==m) to parallel side thru P2
  v.x = P[2].x-P[1].x; v.y = P[2].y-P[1].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P3 side (slope==m) to parallel side thru P0
  v.x = P[0].x-P[3].x; v.y = P[0].y-P[3].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  //see that side > length from P3 side (slope==m) to parallel side thru P2
  v.x = P[2].x-P[3].x; v.y = P[2].y-P[3].y;
  altside = sqrt((v.x*v.x)+(v.y*v.y)-((v.x+m*v.y)*(v.x+m*v.y))/(1+m*m));
  if(altside>side) return true;
  return false;
}

//*****
//true if 2 of Pt[] are on one of the 4 ver/horz lines
bool TwoOnLine(int R, int L, int hi, int lo){
        int cnt=0;
        FOR(k,4) if(P[k].x==L) cnt++;
        if (cnt>1) {
          return true;
        }
        cnt=0;
        FOR(k,4) if(P[k].x==R) cnt++;
        if (cnt>1) {
          return true;
        }
        cnt=0;
        FOR(k,4) if(P[k].y==lo) cnt++;
        if (cnt>1) {
          return true;
        }
        cnt=0;
        FOR(k,4) if(P[k].y==hi) cnt++;
        if (cnt>1) {
          return true;
        }
     return false;
}

//******

//true if there is a P[] on each side of HV square
bool OnHVSquare(int R, int L, int hi, int lo){

  FOR(k,4){
    if((P[k].x>R || P[k].x<L ||P[k].y>hi || P[k].y<lo)         //outside
      || (P[k].x!=R && P[k].x!=L && P[k].y!=hi && P[k].y!=lo)) //or off line
      return false;
  }
 
  return true;
}

//******

int main(){
  int n;
  int Disc, A, B;
  double m1, m2;
  int L,R,lo,hi;
  int cnt;
  int caseno=1;
  double s;
  Slope slope;
  double cos1, cos3, cosSlope;

  cin>>n;
  FOR(i,n){
    cout<<"Case "<<caseno++<<": ";
    //get 4 points;
    FOR(j,4) cin>>P[j].x>>P[j].y;
    //sort so P[0] is lowest (left) and around counterclockwise
    //1st check in any 3 pts colinear. If so, no square
    if (IsColinear()){
      cout<<"no solution"<<endl;
    }
    else {
      SortPts();
IFDB PrintPts();
      //compute vectors of opposite points
      v1.x=P[2].x-P[0].x;
      v1.y=P[2].y-P[0].y;
      v2.x=P[3].x-P[1].x;
      v2.y=P[3].y-P[1].y;
IFDB PrintVectors();
      //first see if vectors are ortho and same length
      //so, area = twice are of (small) rectangle containing these points -
      // (add triangles to "outside" of rectangle: may not be unique)
      if (v1.x*v2.x+v1.y*v2.y == 0 && (v1.x*v1.x+v1.y*v1.y == v2.x*v2.x+v2.y*v2.y)){
//        cout<<sqrt((v1.x*v1.x+v1.y*v1.y))+10<<endl;
        printf("%.2f\n", sqrt((v1.x*v1.x+v1.y*v1.y))+10);
      }
      // now if ortho but not equal, no sol
      else if (v1.x*v2.x+v1.y*v2.y == 0){
        cout<<"no solution"<<endl;
      }
      else {
        //now check of horz/vert square thru the points
        //find left/rightmost x coord and hi/low y coord:
        lo = P[0].y;
        hi = P[1].y;
        if (hi<P[2].y) hi=P[2].y;
        if (hi<P[3].y) hi=P[3].y;
        L = P[0].x;
        if (L>P[1].x) L = P[1].x;
        if (L>P[2].x) L = P[2].x;
        if (L>P[3].x) L = P[3].x;
        R = P[0].x;
        if (R<P[1].x) R = P[1].x;
        if (R<P[2].x) R = P[2].x;
        if (R<P[3].x) R = P[3].x;
        if ((R-L == hi-lo) &&
          !TwoOnLine(R,L,hi,lo) && OnHVSquare(R,L,hi,lo)){
IFDB cout<<" all 4 points on the HV square"<<endl;
//           cout<< sqrt((hi-lo)*(hi-lo))+10<<endl;
           printf("%.2f\n", sqrt((hi-lo)*(hi-lo))+10);
         }
      else {
      //there is no HV square
      //so solve for slope (derived from projection formulae)
      //where lengths of sides equal
      // 2 possible slopes thru P[0] (and the parallel side thru P[2])
      double A1, A2;
      A1 = A2 = -1;
      if (v1.x-v2.y!=0 && v1.y + v2.x!=0){
        m1 = (v1.y + v2.x)/(double)(v1.x - v2.y);
        A1 = v1.x*v1.x+v1.y*v1.y -(v1.x*v1.x+2.0*m1*v1.x*v1.y+m1*m1*v1.y*v1.y)/(m1*m1+1);
      }
 
      if (v1.x+v2.y!=0 && v1.x - v2.y!=0){
        m2 = (v1.y - v2.x)/(double)(v1.x + v2.y);
        A2 = v1.x*v1.x+v1.y*v1.y -(v1.x*v1.x+2.0*m2*v1.x*v1.y+m2*m2*v1.y*v1.y)/(m2*m2+1);
      }
IFDB cout<<" areas: "<<A1<<" "<<A2<<" slopes: "<<m1<<" " <<m2<<endl;
      if(A1>0 && A1>=A2) {
        if(IsDegenerate(A1,m1)){
          cout<<"no solution"<<endl;
        }
        else{
          //finally check no point is a vertex: if slope between points = m1 or -1/m
          s = (P[1].y-P[0].y)/(double)(P[1].x-P[0].x);
          if (IsEq(s,m1) || IsEq(s,-1/m1)){
            cout<<"no solution"<<endl;
          }
          else {
            s = (P[3].y-P[0].y)/(double)(P[3].x-P[0].x);
            if (IsEq(s,m1) || IsEq(s,-1/m1)){
              cout<<"no solution"<<endl;
            }
            else {
              //now check from p2 to p1 and p3
              s = (P[1].y-P[2].y)/(double)(P[1].x-P[2].x);
              if (IsEq(s,m1) || IsEq(s,-1/m1)){
                cout<<"no solution"<<endl;
              }
              else{
                s = (P[3].y-P[2].y)/(double)(P[3].x-P[2].x);
                if (IsEq(s,m1) || IsEq(s,-1/m1)){
                  cout<<"no solution"<<endl;
                }
                else {
                  //got the area  (=A1)
//                  cout<<sqrt(A1)+10<<endl;
                  printf("%.2f\n", sqrt(A1)+10);
                }
              }
            }
          }
        }
      } //if(A1>0 ... )
      else if(A2>0 && A2>A1){
        //check if degenerate
        if(IsDegenerate(A2,m2)){
          cout<<"no solution"<<endl;
        }
        else{
          //finally check no point is a vertex: if slope between points = m2 or -1/m2
          s = v1.y/(1.0*v1.x); //line p1-p0
          if (IsEq(s,m1) || IsEq(s,-1/m1)){
            cout<<"no solution"<<endl;
          }
          else {
            s = v3.y/(1.0*v3.x); //line p3-p0
            if (IsEq(s,m1) || IsEq(s,-1/m1)){
              cout<<"no solution"<<endl;
            }
            else {
              //now check from p2 to p1 and p3
              v1.x = P[1].x-P[2].x;  v1.y=P[1].y-P[2].y;
              v3.x = P[3].x-P[2].x;  v3.y=P[3].y-P[2].y;
              s = v1.y/(1.0*v1.x); //line p1-p2
              if (IsEq(s,m1) || IsEq(s,-1/m1)){
                cout<<"no solution"<<endl;
              }
              else {
                s = v3.y/(1.0*v3.x); //line p3-p0
                if (IsEq(s,m1) || IsEq(s,-1/m1)){
                  cout<<"no solution"<<endl;
                }
                else {
                  //got the area (= A2)
//                  cout<<sqrt(A2)+10<<endl;
                  printf("%.2f\n", sqrt(A2)+10);
                }
              }
            }
          }
        }
       }
       else{  //both A1==-1 and A2==-1
         cout<<"no solution"<<endl;
       }
     }
   }
  }
IFDB    cout<<"end of case"<<endl<<endl;
  }
  return 0;
}