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

/**
 * Solution to 3D Printer.
 * 
 * @author vanb
 */
public class threedprinter_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A 3D Point.
     * 
     * @author vanb
     */
    public class Point3D
    {
        public double x, y, z;
        
        /**
         * Distance from this point to another point.
         * 
         * @param p Another point
         * @return Distance from here to p
         */
        public double distanceTo( Point3D p )
        {
            double dx = p.x-x;  
            double dy = p.y-y;  
            double dz = p.z-z;
            
            return Math.sqrt( dx*dx + dy*dy + dz*dz );          
        }
    }
    
    /** This is the number of vertices of a polygon */
    public int v;
    /** These points form a polygon */
    public Point3D points[];
    
    /**
     * Read a polygon from the input, and allocate all of the structures.
     */
    public void readpoly()
    {
        v = sc.nextInt();
        points = new Point3D[v];
        for( int i=0; i<v; i++ )
        {
            points[i] = new Point3D();
            points[i].x = sc.nextDouble();
            points[i].y = sc.nextDouble();
            points[i].z = sc.nextDouble();
        }
    }
        
    /**
     * Area of a triangle, given the lengths of the 3 sides, using Heron's formula.
     * 
     * @param a A side
     * @param b Another side
     * @param c The third side
     * @return The area of a triangle with sides of length a, b and c
     */
    public double triarea( double a, double b, double c )
    {
        double s = 0.5*(a+b+c);
        return Math.sqrt( s*(s-a)*(s-b)*(s-c) );
    }
    
    /**
     * Determinant of a 2x2 matrix.
     * 
     * @param a Top Left
     * @param b Top Right
     * @param c Bottom Left
     * @param d Bottom Right
     * @return Determinant
     */
    public double det( double a, double b, double c, double d )
    {
        return a*d-b*c;
    }
    
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out; 
        
        for(;;)
        {
            // This is the number of solids
            int n = sc.nextInt();
            if( n==0 ) break;
            
            double volume = 0.0;
            for( int i=0; i<n; i++ )
            {
                // This is the number of polygons in this solid.
                int k = sc.nextInt();
                
                // We're going to find the volume of the solid by splitting it into pyramids.
                // We're going to choose a point arbitrarily to be the 'top' of the pyramids
                // Then, we'll let each polygon be the base of a pyramid with that top,
                // find the volumes of all of those pyramids, and add them all up to get 
                // the total volume of the solid.
                
                // Read the first polygon.
                readpoly();
                
                // Arbitrarily choose its first point as the top of all of the pyramids
                Point3D top = points[0];                
                
                // Now, go through all of rest of the faces of this polygon, form pyramids,
                // add up the volumes. Note that the first face can't contribute any volume.
                // Since our "top" point is on the first face, the height of its pyramid 
                // would be 0, so its volume would be 0.
                for( int p=1; p<k; p++ )
                {
                    // Read the next polygon
                    readpoly();
                    
                    // First, find the area of polygon. We'll do this with a similar trick, 
                    // by splitting it into triangles. This will work because we're guaranteed
                    // that the solid is convex, so all of its faces must be convex.
                    //
                    // We'll choose a point P arbitrarily (we'll use the first one), 
                    // and then for every edge of the polygon A-B (where A!=P and B!=P)
                    // we'll add in the area of triangle P-A-B. 
                    // 
                    // Terminology: We'll call P-A and P-B 'struts', and A-B is the 'roof'.
                    double basearea = 0.0;
                    double laststrut = points[0].distanceTo( points[1] );
                    for( int f=2; f<v; f++ )
                    {
                        double roof = points[f-1].distanceTo( points[f] );
                        double nextstrut = points[0].distanceTo( points[f] );
                        basearea += triarea( laststrut, roof, nextstrut );
                        laststrut = nextstrut;
                    }
                    
                    // Now, to find the height of the pyramid. That's the distance from
                    // the top point to the plane of the polygon. We'll use the first three points
                    // of the polygon to find the normal (and thus the equation) of the plane.
                    double a = det(points[1].y-points[0].y, points[1].z-points[0].z,
                                   points[2].y-points[0].y, points[2].z-points[0].z );     
                    
                    double b = det(points[1].z-points[0].z, points[1].x-points[0].x,
                                   points[2].z-points[0].z, points[2].x-points[0].x );   
                    
                    double c = det(points[1].x-points[0].x, points[1].y-points[0].y,
                                   points[2].x-points[0].x, points[2].y-points[0].y );                    
                                   
                    double d = -(a*points[0].x + b*points[0].y + c*points[0].z);  
                    
                    for( Point3D q : points )
                    {
                        double test = Math.abs(a*q.x+b*q.y+c*q.z+d);
                        if( test>0.0001 ) System.err.println( "PANIC! Polygon isn't in a plane!" );
                    }
                    
                    // OK, now that we know the equation of the plane (ax+by+cz+d=0),
                    // we can find the distance of the top, and thus the height of the pyramid.
                    double height = Math.abs((a*top.x+b*top.y+c*top.z+d)/(Math.sqrt( a*a+b*b+c*c )));
                    
                    // Add in the volume of the pyramid.
                    volume += height * basearea / 3.0;                    
                }               
            }
            
            // Judges' stuff, to make sure roundoff error isn't a problem.
            String answer = String.format( "%.4f", volume );
            if( answer.endsWith( "50" ) || answer.endsWith( "49" ) )
            {
                System.err.println( answer + " is too close to a cusp");
            }
            System.out.println( answer );
            
            // Print the answer!
            ps.printf( "%.2f", volume );
            ps.println();
        }
    }

    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new threedprinter_vanb().doit();
    }

}