#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-5;
inline double dot(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
inline double cross(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
inline int cmp(double a, double b) {
  const double diff = a - b;
  if (fabs(diff) < EPS) return 0;
  return diff < 0 ? -1 : 1;
}
bool intersect(const complex<double> &pa, const complex<double> &pb,
               const complex<double> &qa, const complex<double> &qb) {
  if (cross(pb - pa, qa - pa) * cross(pb - pa, qb - pa) >= 0) return false;
  if (cross(qb - qa, pa - qa) * cross(qb - qa, pb - qa) >= 0) return false;
  return true;
}
bool in_polygon(const complex<double> &p,
                const vector<complex<double> > &polygon) {
  const int N = polygon.size();
  int cnt = 0;
  for (int i = 0; i < N; ++i) {
    const int ni = (i + 1) % N;
    if (cmp(cross(polygon[ni] - polygon[i], p - polygon[i]), 0) == 0 &&
        cmp(dot(polygon[ni] - p, polygon[i] - p), 0) <= 0)
      return true;
    if ((cmp(polygon[i].imag(), p.imag()) <= 0 &&
         cmp(polygon[ni].imag(), p.imag()) > 0) ||
        (cmp(polygon[ni].imag(), p.imag()) <= 0 &&
         cmp(polygon[i].imag(), p.imag()) > 0)) {
      double vt = (p.imag() - polygon[i].imag()) /
                  (polygon[ni].imag() - polygon[i].imag());
      if (cmp(p.real(), (polygon[i].real() + (vt * (polygon[ni].real() -
                                                    polygon[i].real())))) < 0) {
        ++cnt;
      }
    }
  }
  return cnt % 2 == 1;
}
bool can_see(int a, int b, const vector<complex<double> > &polygon) {
  const int N = polygon.size();
  const complex<double> pa = polygon[a];
  const complex<double> pb = polygon[b];
  const complex<double> delta = (pb - pa) / abs(pb - pa) * 0.5;
  for (int i = 0; i < N; ++i) {
    const int ni = (i + 1) % N;
    if (abs(polygon[i] - pb) < EPS) continue;
    if (abs(polygon[ni] - pb) < EPS) continue;
    if (intersect(pa, pb, polygon[i], polygon[ni])) return false;
    if (cmp(cross(pb - pa, polygon[i] - pa), 0) == 0 &&
        cmp(dot(pa - polygon[i], pb - polygon[i]), 0) <= 0) {
      const complex<double> cp = polygon[i] + delta;
      if (!in_polygon(cp, polygon)) return false;
    }
  }
  return true;
}
bool solve() {
  int N;
  cin >> N;
  if (!N) return false;
  vector<complex<double> > polygon(N);
  for (int i = 0; i < N; ++i) {
    double x, y;
    cin >> x >> y;
    polygon[i] = complex<double>(x, y);
  }
  vector<bool> visible(N);
  int ans = N;
  for (int pat = 0; pat < (1 << N); ++pat) {
    fill(visible.begin(), visible.end(), false);
    int popcnt = 0;
    for (int i = 0; i < N; ++i) {
      if (!(pat & (1 << i))) continue;
      ++popcnt;
      visible[i] = true;
      for (int j = 0; j < N; ++j) {
        if (!visible[j] && can_see(i, j, polygon)) {
          visible[j] = true;
        }
      }
    }
    bool ok = true;
    for (int i = 0; i < N; ++i) {
      if (!visible[i]) ok = false;
    }
    if (ok) {
      ans = min(ans, popcnt);
    }
  }
  cout << ans << endl;
  return true;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  while (solve())
    ;
  return 0;
}
