#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
#ifndef FAST_IO
 #define IOS ios_base::sync_with_stdio(false);cin.tie(nullptr);
#endif

#define FILE_IO freopen("input.txt","r",stdin)
#define int long long
#define f first
#define s second
#define endl '\n'
#define all(c) c.begin(),c.end()
#define bp __builtin_popcount
#define debug(x) cerr << #x << " = " << x << endl;

const int MOD = 1e9 + 7;
const int INF = 1e18;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>void print(T t){for(auto &it : t)cout<<it<<" ";}
inline int powerexp(int a, int b, int m = MOD){ int res = 1;while(b){if(b&1)res = res * a % m;a = a * a % m,b >>= 1;}return res % m;}
inline int modinv(int a){ return powerexp(a,MOD-2,MOD);}
inline int lcm(int a, int b){ int g = __gcd(a,b);return a/g*b;}
inline int add(int x, int y){ x += y; if (x >= MOD) x -=  MOD; return x;}
inline int mul(int x, int y){ return (x * 1ll * y) % MOD;}
inline int sub(int x, int y){ x -= y; if (x<0) x += MOD; return x ;}

//-------------------< start here >-------------------------// 

static const double PI = acos(-1);
#define EPS 1e-10

/*
 * yutaka geometry template inspired
*/
class point{
  public:
  double x, y;
  
  point (double x = 0, double y = 0) : x(x), y(y) {}
  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(x * a, y *a );}
  point operator / (double a) { return point(x / a, y /a );}
  bool operator < (const point &p) const {
	 return x != p.x ? x < p.x : y < p.y; 
   }
  bool operator == (const point &p){
	return fabs(x - p. x) < EPS && fabs(y - p.y) < EPS; 
   }
  double hypot(){ return x * x + y * y;}
  double abs(){ return sqrt(hypot());}	
};

double norm(point a){ return a.x * a.x + a.y * a.y;}
double abs(point a){ return (double)sqrt(norm(a));}
point polar(double a, double r){ return point(cos(r) * a, sin(r) * a);}
double dot_product(point a, point b){ return a.x * b.x + a.y * b. y;}
double cross_product(point a, point b){ return a.x * b.y - a.y * b. x;}

bool coordinatecmp(const point &p1, const point &p2){
  if (p1.y == p2.y) return p1.x < p2.x;
  else return p1.y < p2.y;
  //overloaded comparison function
}

int ccw(point p0, point p1, point p2){
  point a = p1 - p0;
  point b = p2 - p0;
  if (cross_product(a, b) > EPS) return 1; //anti clock
  if (cross_product(a, b) < EPS) return -1; // clock
  else return 0; // on same segment	
}

/*
 * Polar Sort 
 * */
class PolarAngCmp{
  public:
  point p;
  PolarAngCmp( point p) : p(p) {}
  bool operator() (const point &p1, const point &p2) {
	  point a = point(p1.x - p.x, p1.y - p.y);
	  point b = point(p2.x - p.x, p2.y - p.y);
	  double c = cross_product(a, b);
	  if (c == 0) return abs(a) < abs(b);
	  return c > 0;
  }
};

vector<point> GrahamScan(vector<point> s){
  // for finding convex hull
  vector<point> hull;
  point x = *min_element(s.begin(), s.end(), coordinatecmp);
  sort(s.begin(), s.end(), PolarAngCmp(x));
  for(int i = 0; i <= 2; i++) hull.push_back(s[i]);
  for(int i = 3; i < (int)s.size(); i++){
	  while(hull.size() >= 2 && ccw(hull[(int)hull.size() - 2], hull.back(), s[i]) == -1 ){
		 hull.pop_back();
	 }
		 hull.push_back(s[i]);  
	}
  return hull;	
}

void solve(){
   vector<point> pol, hull;
   char ch;
   int n;
   while(cin >> n && n){
	   pol.clear();
	   double x, y;
	   for(int  i = 0; i < n; i++){
		   cin >> x >> ch >> y;
		   pol.push_back(point(x, y));  
		 }
	  hull = GrahamScan(pol);
	  int ret = (int)pol.size() - (int)hull.size();
	  cout << ret << endl;  
	 }	
}

//-----------------------------
//comment from here for TOPCODER 
int32_t main(){
   IOS;
   solve();
   //find();
   #ifdef LOCAL_DEFINE
   cerr << "time elapsed " << (double)clock()/CLOCKS_PER_SEC << endl;
   #endif
}

