import java.awt.geom.*;
import java.awt.*;
import java.io.*;
import java.util.StringTokenizer;

class CrystalClear {
    public static void main(String[] args) throws IOException {
        new CrystalClear().run();
    }

    static int intval(String s) { return Integer.parseInt(s); }

    public void run() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tk;
        int n = 0;
        while(true) {
            tk = new StringTokenizer(in.readLine().trim());
            int np = intval(tk.nextToken());
            if(np == 0) break;
            Polygon poly = new Polygon();

            // Read in |np| points, add to a Polygon
            for(int i = 0; i < np; ++i) {
                tk = new StringTokenizer(in.readLine().trim());
                int px = intval(tk.nextToken());
                int py = intval(tk.nextToken());
//                System.out.println("adding " +px + ",  " + py);
                poly.addPoint(px,py);
            }

            double inscount =0.;

            // Get the bounding box of the polygon
            Rectangle bounds = poly.getBounds();

            // For each point in the bounding box...
            for(int y = bounds.y; y <= bounds.y+bounds.height; ++y) {
                for(int x = bounds.x; x <= bounds.x+bounds.width; ++x) {
                    //System.out.println("\tpt " +x + ",  " + y);
                    // If the point is one of the polygon vertices, discard it
                    //
                    if (isVertex(poly, x, y)) {
//                        System.out.println("\tdicarding as vertex " + x + ", " + y);
                        continue;
                    }

                    // If the point is on one of the line segments, count half its area
                    // [note: "on line segment" counts as "minimum distance to a line segment" == 0
                    // see below
                    //
                    double dist = minDist(poly, x, y);
                    //System.out.println("\tdist is " + dist);
                    if (dist == 0.) {
//                        System.out.println("\tcounting half for " + x + ", " + y);
                        inscount += 0.5;
                    }
                    // If the point is entirely in the polygon,
                    // AND it's less than distance 0.5 from any of the polygon's edges,
                    // count its area (else discard)
                    //
                    else if(poly.contains(x,y) && dist >= 0.5) {
//                        System.out.println("\tcounting full for " + x + ", " + y);
                        inscount += 1;
                    } else {
                    // (else if) the point is outside the polygon, discard it
                    // [note!  This comes last because of "weirdness" about how Java
                    //          defines "insideness" for points on the edges of polygons
//                        System.out.println("\tdicarding as outside " + x + ", " + y);
                    }
                }
            }
            inscount += (np - 2) / 2.0; // Account for polygon vertices

            System.out.println("Shape " + (++n));
            System.out.printf("Insulating area = %.3f cm^2\n", (inscount * Math.PI/4));
        }
        System.out.printf("\n");
    }

    static boolean isVertex(Polygon p, int x, int y) {
        for(int i= 0; i < p.npoints; ++i) {
            int px1 = p.xpoints[i];
            int py1 = p.ypoints[i];
            if(x == px1 && y == py1) return true;
        }
        return false;
    }

    static double minDist(Polygon p, int x, int y) {
        double min = 10000000.;
        double dist;
        int n = p.npoints;
        for(int i= 0; i < n; ++i) {
            int px1 = p.xpoints[i];
            int py1 = p.ypoints[i];
            int px2 = p.xpoints[(i+1)%n];
            int py2 = p.ypoints[(i+1)%n];
            dist = Line2D.ptSegDist(px1, py1, px2, py2, x, y);
            if(dist < min) min = dist;
        }
        return min;
    }

    static double areaOf(Shape s) {
        PathIterator i = s.getPathIterator(null);
        double[] coords = new double[6];
        int r;
        double area = 0.;
        double mx, my, lx, ly, x, y;
        mx= my= lx= ly= 0.; // prevent javac complaints over un-init-ed vars
        while(!i.isDone()) {
            r = i.currentSegment(coords);
            x = coords[0]; y = coords[1];

                   if(r == PathIterator.SEG_LINETO) {
                area += (lx*y - x*ly);
            } else if(r == PathIterator.SEG_CLOSE) {
                area += (lx*my - mx*ly);
            } else if(r == PathIterator.SEG_MOVETO) {
                mx = x;
                my = y;
            }

            lx = x; ly = y;
            i.next();
        }
        return Math.abs(area/2);
    }
}