g#include <iostream>
#include <complex>
#include <vector>
#include <algorithm>

using namespace std;

const double EPS = 1e-9;

typedef complex<double> P;

inline double dot(const P &a, const P &b) {
    return a.real()*b.real() + a.imag()*b.imag();
}

inline double cross(const P &a, const P &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 P &pa, const P &pb, const P &qa, const P &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 P &p, const vector<P> &polygon) {
    const int N = polygon.size();
    int cnt = 0;
    for(int i = 0; i < N; ++i) {
        const int ni = (i+1) % N;
        //cout << polygon[i] << polygon[ni] << p << cross(polygon[ni]-polygon[i], p-polygon[i]) << endl;
        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(p.real() < (polygon[i].real() + (vt * (polygon[ni].real() - polygon[i].real())))) {
                //cout << "intersect " << p << polygon[i] << polygon[ni] << endl;
                ++cnt;
            }
        }
    }
    //cout << p << cnt << endl;
    return cnt % 2 == 1;
}

bool can_see(int a, int b, const vector<P> &polygon) {
    const int N = polygon.size();
    const P pa = polygon[a];
    const P pb = polygon[b];
    const P 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(cmp(cross(pb-pa, polygon[i]-pa), 0) == 0 && dot(pa-polygon[i], pb-polygon[i]) <= 0) {
            const P cp = polygon[i] + delta;
            if(!in_polygon(cp, polygon)) return false;
        } else if(intersect(pa, pb, polygon[i], polygon[ni])) return false;
    }
    return true;
}

bool solve() {
    int N;
    cin >> N;
    if(!N) return false;

    vector<P> polygon(N);
    for(int i = 0; i < N; ++i) {
        double x, y;
        cin >> x >> y;
        polygon[i] = P(x, y);
    }
    vector<bool> visible(N);
    int ans = N;
    for(int pat = 0; pat < (1<<N); ++pat) {
    //for(int pat = 0; pat < 2; ++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(can_see(i, j, polygon)) {
                    //cout << i << ' ' << j << endl;
                    visible[j] = true;
                }
            }
        }
        bool ok = true;
        for(int i = 0; i < N; ++i) {
            if(!visible[i]) ok = false;
        }
        if(ok) {
            //if(popcnt == 1) cout << "pat " << pat << endl;
            ans = min(ans, popcnt);
        }
    }
    cout << ans << endl;
    return true;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);

    while(solve()) ;
    return 0;
}