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

/**
 * Solution to Unreal Estate.
 * 
 * @author vanb
 */
public class realestate_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A single coordinate, either x or y.
     * 
     * @author vanb
     */
    public class Coordinate implements Comparable<Coordinate>
    {
        /** The coordinate itself */
        public double value;
        
        /** Is this the low, or the high coordinate? */
        public boolean lo;
        
        /** Which plot this coordinate is part of */
        public Plot plot;
        
        /** Index into the y array (unused for x) */
        public int index;
        
        /**
         * Create a coordinate.
         * 
         * @param value Coordinate value
         * @param lo Is this the low or high coordinate?
         * @param plot The plot that this coordinate is a part of
         */
        public Coordinate( double value, boolean lo, Plot plot )
        {
            this.value = value;
            this.lo = lo;
            this.plot = plot;
            this.index = -1;
        }
        
        /**
         * Compare two coordinates by their value.
         * 
         * @param c Another coordinate
         * @return -1, 0 or 1, as per usual.
         */
        public int compareTo( Coordinate c )
        {
            return Double.compare( value, c.value );
        }
        
        /**
         * Return a pretty string for debugging.
         * 
         * @return A pretty string
         */
        public String toString()
        {
            return "[" + value + "," + lo + "," + index + "]";
        }
    }
    
    /**
     * A plot, recording all 4 coordinates: xlo, ylo, xhi, yhi
     * 
     * @author vanb
     */
    public class Plot
    {
        Coordinate xlo, xhi, ylo, yhi;
    }
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner (System.in);
        ps = System.out; 
        
        for(;;)
        {
            int n = sc.nextInt();
            if( n==0 ) break;
            
            // Read in the data, creating arrays of xs and ys
            Coordinate xs[] = new Coordinate[n+n];
            Coordinate ys[] = new Coordinate[n+n];
            for( int i=0; i<n; i++ )
            {
                int index = i+i;
                Plot p = new Plot();               
                xs[index] = p.xlo = new Coordinate( sc.nextDouble(), true, p );
                ys[index] = p.ylo = new Coordinate( sc.nextDouble(), true, p );
                xs[index+1] = p.xhi = new Coordinate( sc.nextDouble(), false, p );
                ys[index+1] = p.yhi = new Coordinate( sc.nextDouble(), false, p );
            }
            
            // Sort the xs and ys
            Arrays.sort( xs );
            Arrays.sort( ys );
            
            // Go through the ys to figure indices, and also heights between consecutive ys
            double lasty = ys[0].value;
            double heights[] = new double[n+n];
            for( int i=0; i<heights.length; i++ )
            {
                ys[i].index = i;
                if(i>0) heights[i-1] = ys[i].value - lasty;
                lasty = ys[i].value;
            }
            
            // We're going to go through the area in slices, by x coordinate.
            // We'll handle overlap by keeping a count of how many plots each height is in.
            int counts[] = new int[n+n];
            
            // Total height of all plots in a slice
            double totalheight = 0.0;
            
            // This will be our final answer
            double area = 0.0;
            
            // The last x. We'll need this to figure the width of a slice.
            double lastx = 0.0;
            
            for( int i=0; i<xs.length; i++ )
            {
                // Add in the area from this slice
                double thisx = xs[i].value;
                area += (thisx-lastx)*totalheight;
                
                // This is the plot that this x coordinate belongs to
                Plot p = xs[i].plot;
                               
                // Starting a plot. Add to the total height
                if( xs[i].lo )
                {
                    // Go through all of the ys in this plot.
                    // Only add their height to the total height
                    // if they haven't been seen before (count[j]==0)
                    for( int j=p.ylo.index; j<p.yhi.index; j++ )
                    {
                        if( counts[j]==0 ) totalheight += heights[j];
                        ++counts[j];
                    }
                }
                else // Ending a plot. Remove this plot from the total height.
                {
                    // Go through all of the ys in this plot.
                    // Only remove their height from the total height
                    // if this is the last reference (count[j]==0)
                    for( int j=p.ylo.index; j<p.yhi.index; j++ )
                    {
                        --counts[j];
                        if( counts[j]==0 ) totalheight -= heights[j];
                    } 
                }
                
                // We're done. Save the x.
                lastx = thisx;
            }
            
            // Judges' stuff, to make sure roundoff error isn't a problem.
            String answer = String.format( "%.4f", area );
            if( answer.endsWith( "50" ) || answer.endsWith( "49" ) )
            {
                System.out.println( answer + " is on a cusp");
            }
            
            // Print the answer!
            ps.printf( "%.2f", area );
            ps.println();
        }
    }

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

}