import java.io.*;
import java.util.*;
import java.math.*;

/**
 * Solution to Super Mario 169
 * 
 * This problem is just a repeated application of a memoized Hamiltonian Path algorithm.
 * 
 * We'll do some special things. In each case, we'll have a source and a list of points.
 * We'll go backwards, and find the shortest Hamiltonian Path from each point back to the source.
 * In most cases, Switches will be the source and Coins will be the points.
 * In the last case, Mario's Start is the source and the Switches are the points.
 * In each case, node 0 will be the source.
 * 
 * @author vanb
 */
public class mario_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /** 
     * A 3D point.
     * 
     * @author vanb
     */
    private class Point
    {
        /** Integer coordinates */
        public int x, y, z;
        
        /**
         * Create a point.
         * 
         * @param x X coord
         * @param y Y coord
         * @param z Z coord
         */
        public Point( int x, int y, int z )
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }
        
        /**
         * Distance from this point to another point.
         * 
         * @param p Another point
         * @return Distance from this point to P
         */
        public double distance( Point 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 );
        }
        
        /**
         * A pretty String for debugging.
         * 
         * @return A pretty String
         */
        public String toString()
        {
            return "[" + x + "," + y + "," + z + "]";
        }
    }
    
    /** Memoization array for Hamiltonian Path */
    public double memo[][] = new double[14][1<<15];
    
    /** Distances between points */
    public double dists[][] = new double[15][15];
    
    /** This is the state that the Hamiltonian Path code is trying to reach. */
    public int target;
    
    /** This is the number of points in a Hamiltonian Path subproblem */
    public int npoints;
    
    /**
     * This is the shortest path from this node to node 0, avoiding nodes already visited.
     * The state represents the nodes you've already visited, each state is a bit.
     * Node x is bit 1<<x.
     * 
     * @param node
     * @param state
     * @return The least distance to travel from this node to the source going through all nodes that haven't been visited yet.
     */
    public double best( int node, int state )
    {
        // If we've seen it before then there's no need to recompute.
        if( memo[node][state]<0.0 )
        {
            // If we've reached our target state (which is every node except node 0)
            if( state==target )
            {
                // Distance is the distance from this node to node 0
                memo[node][state] = dists[node][0];
            }
            else
            {
                // Otherwise find the best path from here to node i, then from node i to node 0,
                // only going through nodes we haven't visited yet (i.e. not in our 'state')
                double bestsofar = Double.MAX_VALUE;
                for( int i=1; i<=npoints; i++ ) if( (state&(1<<i))==0 )
                {
                    bestsofar = Math.min( bestsofar, dists[node][i] + best( i, state|(1<<i) ) );
                }
                memo[node][state] = bestsofar;
            }
        }
        return memo[node][state];
    }
    
    /**
     * Compute all best Hamiltonian Paths starting at each node and ending up back at the source.
     * 
     * @param k The number of points
     * @return An array of best costs for each point.
     */
    public double[] allbests( int k )
    {
        double bests[] = new double[k];
        npoints = k;
        
        // Our target is to have visited every node except node 0,
        // since that's the source and we want to get there last.
        target = ((1<<npoints)-1)<<1;
        
        for( int i=0; i<=npoints; i++ )
        {
            Arrays.fill( memo[i], -1.0 );
        }
        
        for( int i=1; i<=npoints; i++ )
        {
            bests[i-1] = best( i, 1<<i );
        }
        
        return bests;
    }
    
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "mario.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "mario.vanb" ) );
        
        for(;;)
        {
            int n = sc.nextInt();
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            if( n==0 ) break;
            
            Point start = new Point( x, y, z );
            
            Point switches[] = new Point[n];
            Point coins[][] = new Point[n][];
            double bests[][] = new double[n][];

            for( int s=0; s<n; s++ )
            {
                int k = sc.nextInt(); 
                x = sc.nextInt();
                y = sc.nextInt();
                z = sc.nextInt();
                switches[s] = new Point( x, y, z );
                coins[s] = new Point[k];
                for( int c=0; c<k; c++ )
                {
                    x = sc.nextInt();
                    y = sc.nextInt();
                    z = sc.nextInt();
                    coins[s][c] = new Point( x, y, z );
                }
                
                // Fill in the distance array
                dists[0][0] = 0.0;
                for( int i=1; i<=k; i++ )
                {
                    // Node 0 is the switch
                    dists[0][i] = dists[i][0] = switches[s].distance( coins[s][i-1] );
                    for( int j=i; j<=k; j++ )
                    {
                        dists[i][j] = dists[j][i] = coins[s][i-1].distance( coins[s][j-1] );
                    }
                }
                
                // Get all the bests for this switch
                bests[s] = allbests( k );                
            }
            
            // Fill in the distances for the final Hamiltonian Path
            dists[0][0] = 0.0;
            double min;
            for( int i=1; i<=n; i++ )
            {
                // Node 0 is Mario's start
                dists[i][0] = dists[0][i] = start.distance( switches[i-1] );
                dists[i][i] = 0.0;
                
                // The distance from one switch to another has to
                // include the Hamiltonian path among the coins of the second
                // (in the spirit of the problem, we're going backwards).
                // We'll look for the best option.
                // Also note that it's possible for dists[i][j]!=dists[j][i]
                for( int j=1; j<=n; j++ ) if( j!=i )
                {
                    min = Double.MAX_VALUE;
                    for( int b=0; b<bests[j-1].length; b++ )
                    {
                        min = Math.min( min, switches[i-1].distance( coins[j-1][b] ) + bests[j-1][b] );
                    }
                    dists[i][j] = min;
                }
            }
            
            double results[] = allbests( n );
                   
            // We're almost done, but we need to look at all of the starting
            // (ending, since we're going backward) switches and add in its 
            // Hamiltonian Path. Again, we'll look for the best.
            double answer = Double.MAX_VALUE;
            for( int i=0; i<results.length; i++ )
            {
                min = Double.MAX_VALUE;
                for( int j=0; j<bests[i].length; j++ )
                {
                    min = Math.min(  min, bests[i][j] );
                }
                answer = Math.min( answer, results[i]+min );
            }
            
            ps.printf( "%.2f", answer );
            ps.println();
            
            String ans = String.format( "%.5f", answer );
            if( ans.endsWith( "500" ) || ans.endsWith( "499" )  ) System.err.println( ans );
        }     
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        //long start = System.currentTimeMillis();
        new mario_vanb().doit();        
        //System.out.println( System.currentTimeMillis() - start );
    }   
}