import java.io.*;
import java.util.*;
import java.text.*;

public class Cake {
  // x and y arrays contain vertices and midpoints in counterclockwise order:
  public static double x[] = new double[8], y[] = new double[8];

  // areas with minimum difference:
  public static double mina1,mina2;

  // number of test cases so far:
  public static int count;

  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st;

    String line;
    count= 0;
    while ((line = in.readLine()) != null) {

      // read in the vertices; check for end of file:
      st = new StringTokenizer(line);
      boolean allzero = true;
      for (int i = 0; i < 8; i += 2) {
        x[i] = Double.parseDouble(st.nextToken());
        y[i] = Double.parseDouble(st.nextToken());
        if (x[i] != 0 || y[i] != 0)
          allzero = false;
      }
      if (allzero)
        break;

      count++;
      process();
    }
  }

  // Process a single quadrilateral:
  public static void process() {
    double mindiff = Integer.MAX_VALUE; // minimum difference in areas
    double mina1 = 0,mina2 = 0; // area values that give min. difference

    NumberFormat fmt = NumberFormat.getNumberInstance();
    fmt.setGroupingUsed(false);
    fmt.setMaximumFractionDigits(3);
    fmt.setMinimumFractionDigits(3);

    // Compute midpoints:
    for (int i = 1; i < 8; i += 2) {
      x[i] = (x[i-1] + x[(i+1)%8])/2.0;
      y[i] = (y[i-1] + y[(i+1)%8])/2.0;
    }

    // Find all cuts and their areas;

    // First, all cuts involving at least one vertex:
    for (int first = 0; first < 7; first += 2) {
      for (int second=(first+3)%8; second!=(first + 6)%8; second=(second+1)%8) {
        int poly1[] = new int[8]; // one of the two polygons formed by the cut
        int poly2[] = new int[8]; // the other polygon

      // Polygon to the "left" of the cut:
        poly1[0] = first;
        int loc1 = 1;
        for (int i = (first+1)%8; i != second; i = (i+1)%8) {
          if (i%2==0) {
            poly1[loc1++] = i;
          }
        }
        poly1[loc1++] = second;

      // Polygon to the "right" of the cut:
        poly2[0] = first;
        int loc2 = 1;
        for (int i = second; i != first; i = (i+1)%8) {
          if (i%2==0 || i == second) {
            poly2[loc2++] = i;
          }
        }

        double area1 = area(poly1, loc1);
        double area2 = area(poly2, loc2);
        if (Math.abs(area1-area2) < mindiff) {
          mindiff = Math.abs(area1-area2);
          mina1 = Math.min(area1,area2);
          mina2 = Math.max(area1,area2);
        }
      }
    }

    // Next, all cuts that involve only midpoints:
    for (int first = 1; first < 8; first += 2) {
      for (int second=(first+2)%8; second!=first; second=(second+2)%8) {
        int poly1[] = new int[8];
        int poly2[] = new int[8];

      // Polygon to the "left" of the cut:
        poly1[0] = first;
        int loc1 = 1;
        for (int i = (first+1)%8; i != second; i = (i+1)%8) 
          if (i%2==0) {
            poly1[loc1++] = i;
          }
        poly1[loc1++] = second;

      // Polygon to the "right" of the cut:
        poly2[0] = first;
        int loc2 = 1;
        for (int i = second; i != first; i = (i+1)%8) 
          if (i%2 == 0 || i == second) {
            poly2[loc2++] = i;
          }
        double area1 = area(poly1, loc1);
        double area2 = area(poly2, loc2);
        if (Math.abs(area1-area2) < mindiff) {
          mindiff = Math.abs(area1-area2);
          mina1 = Math.min(area1,area2);
          mina2 = Math.max(area1,area2);
        }
      }
    }
    System.out.println("Cake " + count + ": " + 
           fmt.format(mina1) + " " + fmt.format(mina2));
  }


  // Finds area of a triangle given counterclockwise traversal of
  // its perimeter (in the form of indices i, j, k to the x and y arrays):
  public static double triarea(int i, int j, int k) {
    return x[i]*y[j] - y[i]*x[j] + y[i]*x[k] - x[i]*y[k] +
           x[j]*y[k] - x[k]*y[j];
  }


  // Finds area of a polygon given counterclockwise traversal of
  // its perimeter (in the form of an array "poly" of indices of x, y arrays:
  public static double area(int poly[], int numvert) {
    double sum = 0;
    for (int i = 1; i < numvert-1; i++)
       sum += triarea(poly[0],poly[i],poly[i+1]);
    return .5*sum;
  }

}