#include <iostream>
using namespace std;

#define SAFE_DELETE( x ) { if ( x ){ delete x; x = NULL; } }

class Vector2{
public:
	Vector2() : x( 0 ), y( 0 ), round( false ), check( false ), prev( NULL ), next( NULL ){}
	Vector2( double aX, double aY ) : round( false ), check( false ), prev( NULL ), next( NULL ){
		x = aX;
		y = aY;
	}
	Vector2( Vector2 a, Vector2 b ) : round( false ), check( false ), prev( NULL ), next( NULL ){
		x = b.x - a.x;
		y = b.y - a.y;
	}

	Vector2 normal( Vector2& a ){
		Vector2 ret;
		ret.x = a.y - y;
		ret.y = x - a.x;
		return ret;
	}
	double dot( Vector2& a ){
		return x * a.x + y * a.y;
	}
	double cross( Vector2& a ){
		return x * a.y - y * a.x;
	}

	void operator=( Vector2& a ){
		x = a.x;
		y = a.y;
	}

	bool round, check;
	double x, y;
	Vector2 *prev, *next;
};

class VecList{
public:
	VecList() : mSize( 0 ), head( NULL ), tail( NULL ){
		head = new Vector2;
		tail = new Vector2;
		head->next = tail;
		tail->prev = head;
	}
	~VecList(){
		init();
		SAFE_DELETE( tail );
		SAFE_DELETE( head );
	}

	void init(){
		for ( int i = mSize; i > 0; --i ){
			Vector2* a = tail->prev;
			a->prev->next = a->next;
			a->next->prev = a->prev;
			SAFE_DELETE( a );
		}
		mSize = 0;
	}
	void pushBack( Vector2 v ){
		Vector2* a = new Vector2( v.x, v.y );
		a->prev = tail->prev;
		a->next = tail;
		a->prev->next = a;
		a->next->prev = a;
		++mSize;
	}
	int cntRound(){
		int cnt = 0;
		double top, right, bottom, left;
		Vector2 *it, *topR, *topL, *rightU, *rightD, *bottomR, *bottomL, *leftU, *leftD;
		top = bottom = head->next->y;
		right = left = head->next->x;
		topR = topL = rightU = rightD = bottomR = bottomL = leftU = leftD = NULL;
		it = head;
		for ( int i = 0; i < mSize; ++i ){
			it = it->next;
			if ( it->y > top ) top = it->y;
			if ( it->y < bottom ) bottom = it->y;
			if ( it->x > right ) right = it->x;
			if ( it->x < left ) left = it->x;
		}
		it = head;
		for ( int i = 0; i < mSize; ++i ){
			it = it->next;
			if ( it->x == right ){
				if( !rightU ){
					rightU = rightD = it;
					rightU->round = true;
				}else{
					rightD = it;
					rightD->round = true;
					if ( rightU->y < rightD->y ) swap( rightU, rightD );
				}
			}
			if ( it->x == left ){
				if( !leftU ){
					leftU = leftD = it;
					leftU->round = true;
				}else{
					leftD = it;
					leftD->round = true;
					if ( leftU->y < leftD->y ) swap( leftU, leftD );
				}
			}
			if ( it->y == top ){
				if( !topR ){
					topR = topL = it;
					topR->round = true;
				}else{
					topL = it;
					topL->round = true;
					if ( topR->y < topL->y ) swap( topR, topL );
				}
			}
			if ( it->y == bottom ){
				if( !bottomR ){
					bottomR = bottomL = it;
					bottomR->round = true;
				}else{
					bottomL = it;
					bottomL->round = true;
					if ( bottomR->y < bottomL->y ) swap( bottomR, bottomL );
				}
			}
		}
		if ( !( topL == leftU ) ) checkRound( topL, leftU );
		if ( !( leftD == bottomL ) ) checkRound( leftD, bottomL );
		if ( !( bottomR == rightD ) ) checkRound( bottomR, rightD );
		if ( !( rightU == topR ) ) checkRound( rightU, topR );

		it = head;
		for ( int i = 0; i < mSize; ++i ){
			it = it->next;
			if ( it->round ){
				++cnt;
				cout << "p" << i+1 << " is true." << endl;
			}else{
				cout << "p" << i+1 << " is false." << endl;
			}
		}

		return mSize - cnt;
	}

private:
	void checkRound( Vector2* a, Vector2* b ){
		bool rep = false;
		double right = a->x, left = b->x, top = a->y, bottom = b->y;
		if ( right < left ) swap( right, left );
		if ( top < bottom ) swap( top, bottom );
		Vector2* it = head;
		for ( int i = 0; i < mSize; ++i ){
			it = it->next;
			if( !it->round && it->x > left && it->x < right && it->y > bottom && it->y < top ){
				it->check = true;
				rep = true;
			}
		}
		if ( rep ){
			rep = false;
			Vector2 ab( *a, *b );
			Vector2 *p = a, *pp = NULL;
			it = head;
			for ( int i = 0; i < mSize; ++i ){
				it = it->next;
				if ( it->check ){
					Vector2 ac( *p, *it );
					if ( ab.cross( ac ) < 0 ){
						p = it;
						rep = true;
					}
				}
			}
			if ( rep ){
				p->round = true;
				p->check = false;
				it = head;
				for ( int i = 0; i < mSize; ++i ){
					it = it->next;
					if ( it->check ){
						it->check = false;
						Vector2 ac( *p, *it );
						if ( !ab.cross( ac ) ){
							pp = it;
							pp->round = true;
							break;
						}
					}
				}
				if ( pp ){
					if ( p->x - a->x > pp->x - a->x ) swap( p, pp );
					checkRound( a, p );
					checkRound( pp, b );
				}else{
					checkRound( a, p );
					checkRound( p, b );
				}
			}
		}
	}

	int mSize;
	Vector2 *head, *tail;
};

int main(){
	int n;
	char c;
	VecList list;

	while ( cin >> n && n ){
		list.init();
		Vector2 a;
		for ( int i = 0; i < n; ++i ){
			cin >> a.x >> c >>a.y;
			list.pushBack( a );
		}

		cout << list.cntRound() << endl;
	}

	return 0;
}