#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <cstdio>
#include <climits>
#include <cassert>
#include <complex>
using namespace std;

ifstream fin("G.txt");
#define cin fin

typedef complex<int> point;
struct edge {
  point s;
  point e;

  edge() {}
  edge(point s, point e) : s(s), e(e) {}
};

int paint(vector<vector<int> >& shared, vector<int>& region_color, int idx, int max_idx)
{
  if (idx == max_idx) { 
    vector<int> color(10);
    for (int i = 0; i < region_color.size(); ++i) {
      color[region_color[i]] = 1;
    }
    int num = 0;
    for (int i = 0; i < 10; ++i) { num += color[i]; }
    return num;
  }

  int min_color = 100;
  int color;
  for (int c = 0; c <= idx; ++c) {
    for (int i = 0; i < idx; ++i) {
      if (shared[i][idx] && region_color[i] == c) { goto next_loop; }
    }

    region_color[idx] = c;
    color = paint(shared, region_color, idx + 1, max_idx);
    min_color = min(color, min_color);
  next_loop:
    ;
  }

  return min_color;
}

bool is_edge_shared(const edge& e1, const edge& e2)
{
  point es = e1.e - e1.s;
  point ps = e2.s - e1.s;
  point qs = e2.e - e1.s;

  if (ps.real () * es.imag() != es.real() * ps.imag()) { return false; }

  // cout << e1.s << e1.e << e2.s << e2.e << endl;

  double tp;
  if (es.real() == 0) { tp = ps.imag() / double(es.imag()); }
  else { tp = ps.real() / double(es.real()); }

  if (qs.real () * es.imag() != es.real() * qs.imag()) { return false; }
  double tq;
  if (es.real() == 0) { tq = qs.imag() / double(es.imag()); }
  else { tq = qs.real() / double(es.real()); }

  if (tp <= 0) { return tq > 0; }
  else if (0 < tp && tp < 1) { return true; }
  else { return tq < 1; }
  
}

bool is_some_edge_shared(const vector<edge>& a, const vector<edge>& b)
{
  for (int i = 0; i < a.size(); ++i) {
    for (int j = 0; j < b.size(); ++j) {
      if (is_edge_shared(a[i], b[j])) { return true; }
    }
  }

  return false;
}

int solve(map<string, vector<edge> >& regions)
{
  typedef map<string, vector<edge> > region_t;
  int size = regions.size();
  vector<vector<int> > shared(regions.size(), vector<int>(regions.size()));
  
  int i = 0, j = 0;
  for (region_t::const_iterator it = regions.begin(); it != regions.end(); ++it, ++i) {
    j = i;
    for (region_t::const_iterator that = it;
	 that != regions.end(); ++that, ++j) {
      if (that == it) { continue; }
      shared[i][j] = shared[j][i] = is_some_edge_shared(it->second, that->second);
    }
  }

  vector<int> region_color(size);
  return paint(shared, region_color, 0, size);
}

int main()
{
  if(!fin) return -1;

  int N;
  while (cin >> N, N) {
    string str;
    map<string, vector<edge> > regions;


    for (int i = 0 ; i < N; ++i) {
      getline(cin, str); // chop
      getline(cin, str);

      vector<point> points;
      while (true) {
	int x, y;
	cin >> x;
	if (x == -1) { break; }
	cin >> y;
	points.push_back(point(x, y));
      }

      for (int j = 0; j < points.size(); ++j) {
	regions[str].push_back(edge(points[j], points[(j + 1) % (points.size())]));
      }
    }

    cout << solve(regions) << endl;
  }

  return 0;
}