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

/**
 * Solution to Walls.
 * 
 * @author vanb
 */
public class walls
{
    public Scanner sc;
    public PrintStream ps;
    
    public static final int MAX = 37;
    
    // Number of points
    public int n;
    
    // The Plane
    public boolean plane[][] = new boolean[MAX][MAX];
    
    // Has an x wall been placed here? (Only odd indices will be used)
    public boolean used[] = new boolean[MAX];
    
    // Is there a y value in our past?
    public int ypast[] = new int[MAX];
    
    // Is there an x coordinate here?
    public boolean xval[] = new boolean[MAX];
    
    // Is there a y coordinate here?
    public boolean yval[] = new boolean[MAX];

    // Is there a y wall here?
    public boolean ywall[] = new boolean[MAX];
    
    // Is it useful to put an x wall here?
    public boolean useful[] = new boolean[37];
    
    // Current number of walls used, and best.
    public int wallsplaced, best;
    
    
    /**
     * Place a wall at a given x value.
     * If all x walls are placed, count the number of y walls needed.
     * 
     * @param where x value to place a wall
     */
    public void placewall( int where )
    {
        // Are all x walls placed?
        if( where<0 )
        {
            // Remember this, so we can restore it later
            int wp = wallsplaced;
            
            // Then look to see where we need y walls.
            boolean viable = true;
            
            // We'll divide the space up into bands, where the
            // bands are separated by the x walls.
            // ypast will be indexed by band, not by x!
            Arrays.fill( ypast, -1 );
            
            // k is the number of the current band
            int k=0;            
            Arrays.fill( ywall, false );
                        
            // Go through every point in the plane
            for( int y=0; y<plane[0].length && viable; y+=2 ) if( yval[y] )
            {
                k=0;
                boolean xpast = false;
                for( int x=0; x<plane.length && viable; x++ )
                {
                    // x is even - there might be a point here
                    if( x%2==0 )
                    {
                        // If there is a point...
                        if( plane[x][y] )
                        {
                            // If there is another x in our past with the
                            // same y, not separated by an x wall,
                            // then this is not a viable solution.
                            if( xpast ) viable = false;
                            
                            // Remember that we saw a point at this y
                            xpast = true;
                            
                            // Have we seen a past y in this band?
                            // Then we need to build a y wall - unless we've already built one
                            if( y>0 && ypast[k]>=0 && !ywall[y-1])
                            {
                                // Then we need to build a y wall here
                                // We also need to do something with the ypast array
                                for( int i=0; i<MAX; i++ )
                                {
                                    // Any point below this new wall
                                    // is no longer a problem.
                                    if( ypast[i]<y ) ypast[i]=-1;
                                }
                                ++wallsplaced;
                                ywall[y-1] = true;
                            }
                            
                            // Remember that there's a point in this band
                            ypast[k] = y;
                        }
                    }
                    else
                    {
                        // Odd - this is where x walls might be.
                        // If there's an x wall...
                        if( used[x] ) 
                        {
                            // Increment k to the next band, reset xpast
                            ++k;
                            xpast = false;
                        }
                    }
                }
            }
            
            // If this solution is viable and better, remember it.
            if( viable && wallsplaced<best ) best = wallsplaced;
            
            // Undo
            wallsplaced = wp;
        }
        else if( wallsplaced<best ) // No need to go on if this is already worse
        {
            // Don't place a wall here
            used[where] = false;
            placewall( where-2 );
            
            // Place a wall here, and count it, if it's useful
            if( useful[where] )
            {
                used[where] = true;
                ++wallsplaced;
                placewall( where-2 );
                
                // Undo
                --wallsplaced;
                used[where] = false;
            }
        }
    }
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "walls.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "walls.out" ) ); 
                
        for(;;)
        {
            n = sc.nextInt();
            if( n==0 ) break;
            
            // Initialize the plane
            for( int i=0; i<plane.length; i++ )
            {
                Arrays.fill( plane[i], false );   
            }
            Arrays.fill( xval, false );
            Arrays.fill( yval, false );
            Arrays.fill( useful, false );
            
            // Read in the points
            for( int i=0; i<n; i++ )
            {
                int x = sc.nextInt();
                int y = sc.nextInt();
                plane[x][y] = true;
                xval[x] = true;
                yval[y] = true;
            }
            
            // Figure out where it's useful to put x walls.
            // It's useful to put an x wall immediately before 
            // every used x coordinate except the first one.
            boolean first = true;
            for( int x=0; x<xval.length; x++ )
            {
                if( xval[x] )
                {
                    if( first )
                    {
                        first = false;
                    }
                    else
                    {
                        useful[x-1] = true;
                    }
                }
            }
            
            // Prepare 
            Arrays.fill( used, false );
            wallsplaced = 0;
            best = Integer.MAX_VALUE;
            
            // and recurse!
            placewall( 35 );
            
            // Print the best
            ps.println( best );
        }
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new walls().doit();        
    }

}