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

/**
 * Solution to Goat Ropes.
 * 
 * @author vanb
 */
public class goatropes_vanb 
{
    public Scanner sc;
    public PrintStream ps;
    
    /** A list of all X coordinates */
    public double xs[];
    
    /** A list of all Y coordinates */
    public double ys[];
    
    public static final double epsilon = 0.000001;
    
    /**
     * Distance between posts i and j
     * 
     * @param i A post number
     * @param j Another post number
     * @return The distance between posts i and j
     */
    public double distance( int i, int j )
    {
    	return Math.hypot( ys[j] - ys[i], xs[j] - xs[i] );
    }
    
    /**
     * 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;
        	
        	xs = new double[n];
        	ys = new double[n];
        	for( int i=0; i<n; i++ )
        	{
        		xs[i] = sc.nextDouble();
        		ys[i] = sc.nextDouble();
        	}
        	
        	// The problem reduces to a system of linear equations. 
        	// Let Xi be the length of rope tied to post i, 
        	// and let Dij be the distance between posts i and j. 
        	// The problem is then to maximize the objective function
        	// Sum[Xi] subject to the constraints Xi+Xj<=Dij for i<j.
        	//
        	// This calls for the Simplex algorithm. The Simplex algorithm is
        	// too complex to describe here. (Sorry! I know you're used to me going
        	// into excruciating detail - but not this time!) you can look it up on the 
        	// web - there are many good resources. Once you do, you'll know why it's
        	// important that all Xi's must be >=0, and that setting all Xi's = 0 
        	// forms a Basic Feasible Solution.
   
        	// k is the number of constraints - those are the Xi+Xj<=Dij inequalities.
        	int k = n*(n-1)/2;
        	
        	// Now, create the Simplex matrix.
        	// There are 1+k rows - one for the objective function, and k for the constraints.
        	// There are 1+n+k columns - one for the values, n for the Xi's, and k for the slack variables
        	// associated with the constraints.
        	double m[][] = new double[1+k][1+n+k];
        	
        	// We'll use the first row (that's row 0) for the objective function 
        	// and the remaining k rows for the constraints. 
        	// For convenience, we'll use the first column (which is column 0) for the values,
        	// then columns 1 to n will be the Xi's, and the slack variables will be last.

        	// Start by filling in the objective function.
        	Arrays.fill( m[0], 0.0 );
        	for( int j=1; j<=n; j++ )
        	{
        	    m[0][j] = -1.0;	
        	}
        	
        	// Now, the constraints
        	int row = 0;
        	int slack = n;
        	for( int i=0; i<n; i++ )for( int j=i+1; j<n; j++ )
        	{
        		++row;
        		Arrays.fill( m[row], 0.0 );
        		m[row][0] = distance( i, j );
        		m[row][i+1] = 1.0;
        		m[row][j+1] = 1.0;
        		m[row][++slack] = 1.0;
        	}
        	
        	// Now, Simplex!!
        	for(;;)
        	{
        		// First, find the pivot column - that's the one with
        		// the most negative coefficient in the objective function
        	    double smallest = -epsilon;
        	    int pivotcol = -1;
        	    for( int j=1; j<m[0].length; j++ )
        	    {
        	    	if( m[0][j]<smallest )
        	    	{
        	    		smallest = m[0][j];
        	    		pivotcol = j;
        	    	}
        	    }
        	    
        	    // If there are no negative coefficients, we're done!
        	    if( pivotcol<0 ) break;
        	    
        	    // Now find the pivot row. That's the one where the value divided by the 
        	    // the coefficient in the pivot column is the smallest, but only if that
        	    // coefficient is positive.
        	    smallest = Double.MAX_VALUE;
        	    int pivotrow = -1;
        	    for( int i=1; i<m.length; i++ )
        	    {
        	    	if( m[i][pivotcol]>epsilon )
        	    	{
        	    	    double value = m[i][0]/m[i][pivotcol];
        	    	    if( value<smallest )
        	    	    {
        	    	    	smallest = value;
        	    	    	pivotrow = i;
        	    	    }
        	    	}
        	    }
        	    
        	    // This can't happen!!
        	    if( pivotrow<0 ) 
    	    	{
        	    	System.out.println( "PANIC!! This can't happen.");
    	    	    break;
    	    	}
        	    
        	    // Now, divide the entire pivot row by the pivot value
        	    double pivotval = m[pivotrow][pivotcol];
        	    for( int j=0; j<m[pivotrow].length; j++ )
        	    {
        	        m[pivotrow][j] /= pivotval;	
        	    }
        	    
        	    // Finally, pivot all of the other rows using the pivot row.
        	    for( int i=0; i<m.length; i++ ) if( i!=pivotrow )
        	    {       	        
        	    	pivotval = m[i][pivotcol];
        	    	for( int j=0; j<m[i].length; j++ )
	        	    {
        	        	m[i][j] -= m[pivotrow][j] * pivotval;
        	        }
        	    }
        	}
        	
        	// This is just some debugging stuff.
//        	for( int i=0; i<m.length; i++ )
//        	{
//        		for( int j=0; j<m[i].length; j++ )
//        		{
//        			System.out.printf( " %6.2f", m[i][j] );
//        		}
//        		System.out.println();
//        	}
        	
        	// This is judges' stuff, to make sure roundoff error doesn't bite a team.
        	String answer = String.format( "%.4f", m[0][0] );       	
          	if( answer.endsWith( "50" ) || answer.endsWith( "49" ) ) 
        	{
        	    System.err.println( answer + " is too close to a cusp");
        	}
          	
            // The answer is just the value in the value column of
            // the objective function.
        	ps.printf( "%.2f", m[0][0] );
        	ps.println();
        }
    }
    
    /**
     * The main() just creates an object and calls doit().
     * 
     * @param args Command line args, necessary but unused.
     * @throws Exception
     */
	public static void main( String[] args ) throws Exception
	{
	    long start = System.currentTimeMillis();
        new goatropes_vanb().doit();
        System.err.println( System.currentTimeMillis() - start );
//	    Random random = new Random();
//        for( int i=0; i<10; i++ )
//        {
//            generate( random.nextInt(49) + 2 );
//        }
//        for( int i=0; i<10; i++ )
//        {
//            generate( 50 );
//        }
	}
	
	/**
	 * Generate random input cases.
	 * 
	 * @param n Size of input case.
	 */
	public static void generate( int n )
	{
        boolean field[][] = new boolean[1001][1001];
        Random random = new Random();
  
        System.out.println( n );
        for( int j=0; j<n; j++ )
        {
            for(;;)
            {
                int x = random.nextInt( 1001 );
                int y = random.nextInt( 1001 );
                if( field[x][y] ) continue;
                field[x][y] = true;
                System.out.println( x + " " + y );
                break;
            }
        }	    
	}

}