#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define SIZE 45
#define NUM 0.0001

struct Point{
	Point(double arg_x,double arg_y){
		x = arg_x;
		y = arg_y;
	}

	Point(){
		x = y = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y);}
	Point operator * (double a){ return Point(a*x,a*y); }
	Point operator / (double a){ return Point(x/a,y/a); }

	double abs(){ return sqrt(norm()); }
	double norm(){ return x*x + y*y; }

	bool operator<(const Point &p) const{
		return x != p.x? x < p.x: y < p.y;
	}

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}

	double x,y;
};

typedef Point Vector;
typedef vector<Point> Polygon;

struct Line{
	Point p[2];
	Line(Point p1,Point p2){
		p[0] = p1;
		p[1] = p2;
	}
	Line(){

	}
};

int N;
ll POW[SIZE];
ll can_watch[SIZE];
Polygon polygon;


int func(double x1,double y1,double x2, double y2, double xp, double yp){
	double naiseki,norm1,norm2,gaiseki;
	norm1 = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
	norm2 = sqrt((xp-x1)*(xp-x1)+(yp-y1)*(yp-y1));
	naiseki = (xp-x1)*(x2-x1)+(yp-y1)*(y2-y1);
	gaiseki = (x2-x1)*(yp-y1)-(xp-x1)*(y2-y1);
	if(gaiseki > EPS){
		return 1;
	}else if(gaiseki < -EPS){
		return -1;
	}
	if(naiseki < -EPS){
		return 2;
	}

	if(norm1 < norm2){
		return -2;
	}
	return 0;
}


//★★直線ではなく、線分の交差判定★★
bool is_Cross(Line a,Line b){

	if(func(a.p[0].x,a.p[0].y,a.p[1].x,a.p[1].y,b.p[0].x,b.p[0].y)*
			func(a.p[0].x,a.p[0].y,a.p[1].x,a.p[1].y,b.p[1].x,b.p[1].y) <= 0 &&
			func(b.p[0].x,b.p[0].y,b.p[1].x,b.p[1].y,a.p[0].x,a.p[0].y)*
			func(b.p[0].x,b.p[0].y,b.p[1].x,b.p[1].y,a.p[1].x,a.p[1].y) <= 0){
		return true;
	}
	return false;
}

//交点を求める関数
Point calc_Cross_Point(double x1,double x2,double x3,double x4,double y1,double y2,double y3,double y4){
	Point ret;
	ret.x = ((x2-x1)*(y3*(x4-x3)+x3*(y3-y4))-(x4-x3)*(y1*(x2-x1)+x1*(y1-y2)))/((y2-y1)*(x4-x3)-(y4-y3)*(x2-x1));
	if(x1 != x2){
		ret.y = ((y2-y1)*ret.x+y1*(x2-x1)+x1*(y1-y2))/(x2-x1);
	}else{
		ret.y = ((y4-y3)*ret.x+y3*(x4-x3)+x3*(y3-y4))/(x4-x3);
	}
	return ret;
}

//インタフェース関数
Point calc_Cross_Point(Point a,Point b,Point c,Point d){
	return calc_Cross_Point(a.x,b.x,c.x,d.x,a.y,b.y,c.y,d.y);
}

Point calc_Cross_Point(Line A,Line B){

	return calc_Cross_Point(A.p[0],A.p[1],B.p[0],B.p[1]);
}

double norm(Vector a){
	return a.x*a.x+a.y*a.y;
}

double abs(Vector a){
	return sqrt(norm(a));
}

double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

/*
 * IN 2
 * ON 1
 * OUT 0
 *
 */
int contains(Polygon g,Point p){
	int n = g.size();
	bool x = false;
	for(int i = 0; i < n; i++){
		Point a = g[i]-p,b = g[(i+1)%n]-p;
		if(abs(cross(a,b)) < EPS && dot(a,b) < EPS)return 1;
		if(a.y > b.y)swap(a,b);
		if(a.y < EPS && EPS < b.y && cross(a,b) > EPS) x = !x;
	}
	return (x ? 2:0);
}

int ans;

void recursive(ll used,int index,int guards_num,ll tmp_can_watch){

	if(guards_num >= ans || index == N)return;

	//頂点indexに監視人を置かない
	recursive(used,index+1,guards_num,tmp_can_watch);

	//頂点indexに監視人を置く
	ll next_used = used+POW[index];
	ll next_tmp_can_watch = tmp_can_watch|can_watch[index];

	if(next_tmp_can_watch == POW[N]-1){

		ans = min(ans,guards_num+1);
		return;
	}

	recursive(next_used,index+1,guards_num+1,next_tmp_can_watch);
}

int main(){

	POW[0] = 1;
	for(int i = 1; i < SIZE; i++){

		POW[i] = POW[i-1]*2;
	}

	scanf("%d",&N);

	double X,Y;

	for(int i = 0; i < N; i++){

		scanf("%lf %lf",&X,&Y);
		polygon.push_back(Point(X,Y));
	}

	bool FLG;

	for(int i = 0; i < N; i++){

		can_watch[i] = 0;
	}

	//頂点fromから頂点toを監視できるかをチェック
	for(int from = 0; from < N; from++){
		for(int to = 0; to < N; to++){

			if(to == from){
				can_watch[from] += POW[to];
				continue;
			}

			Line tmp_line = Line(polygon[from],polygon[to]); //頂点from→toの線分

			FLG = true;

			for(int i = 0; i < N; i++){

				Line adj_line = Line(polygon[i],polygon[(i+1)%N]);

				if(!is_Cross(tmp_line,adj_line))continue;

				Vector vec = (polygon[to]-polygon[from])/(abs(polygon[to]-polygon[from]));
				vec = vec*NUM;

				if(contains(polygon,polygon[from]+vec) == 0 || contains(polygon,polygon[to]-vec) == 0){ //線分の端点から少し進んだ点が内部か

					FLG = false;
					break;
				}

				Point cross_point = calc_Cross_Point(tmp_line,adj_line);

				if(abs(tmp_line.p[0]-cross_point) > EPS && abs(tmp_line.p[1]-cross_point) > EPS){ //端点以外での交点

					if(contains(polygon,cross_point+vec) == 0 || contains(polygon,cross_point-vec) == 0){ //交点から少し進んだ点が内部か

						FLG = false;
						break;
					}
				}
			}
			if(!FLG)continue;

			can_watch[from] += POW[to];
		}
	}

	ans = 9;

	recursive(0,0,0,0);

	printf("%d\n",ans);

	return 0;
}



Measured memory_bytes: 3292