// Arup Guha
// Solution to 20013 SE Regional Problem Stars
// 9/30/2014

import java.util.*;

public class stars {

    public static void main(String[] args) {

        Scanner stdin = new Scanner(System.in);
        int n = stdin.nextInt();
        int loop = 1;

        // Go through each case.
        while (n != 0) {

            // Read in points.
            int[][] pts = new int[n][2];
            for (int i=0; i<n; i++)
                for (int j=0; j<2; j++)
                    pts[i][j] = stdin.nextInt();

            // Form graph.
            ArrayList[] g = getGraph(pts);

            // Find components via DFS.
            boolean[] visited = new boolean[n];
            int numComp = 0;
            for (int i=0; i<n; i++) {
                if (!visited[i]) {
                    numComp++;
                    dfs(g, i, visited);
                }
            }

            // Result.
            System.out.println("Universe "+loop+" contains "+numComp+" constellations");

            // Go to next case.
            n = stdin.nextInt();
            loop++;
        }
    }

    public static double getD(int[][] pts, int i, int j) {
        return Math.sqrt( (pts[i][0]-pts[j][0])*(pts[i][0]-pts[j][0]) + (pts[i][1]-pts[j][1])*(pts[i][1]-pts[j][1]) );
    }

    // Typical DFS.
    public static void dfs(ArrayList[] g, int node, boolean[] visited) {
        visited[node] = true;
        for (int i=0; i<g[node].size(); i++)
            if (!visited[(Integer)g[node].get(i)])
                dfs(g, (Integer)g[node].get(i), visited);
    }

    public static ArrayList[] getGraph(int[][] pts) {

        int n = pts.length;
        ArrayList[] g = new ArrayList[n];
        for (int i=0; i<n; i++)
            g[i] = new ArrayList<Integer>();

        // Go through each vertex.
        for (int i=0; i<n; i++) {

            // Find minimum distance.
            double minD = 1000000;
            for (int j=0; j<n; j++) {
                if (i == j) continue;
                double dist = getD(pts, i, j);
                if (dist < minD+1e-9)
                    minD = dist;
            }

            // Find all vertices at that minimum distance from i.
            for (int j=0; j<n; j++) {
                if (i == j) continue;
                double dist = getD(pts, i, j);
                if (dist-minD < 1e-9) {
                    g[i].add(j);
                    g[j].add(i);
                }
            }
        }

        return g;
    }
}