#include <iostream>

using namespace std;

#include <iostream>
#include <set>
#include <map>
#include <cmath>
#include <vector>
#include <complex>
#include <algorithm>

#define rep(i,a,b) for(int i=(a); i<(b); i++)
#define mp make_pair

#define th (*this)
#define mp make_pair

using namespace std;

typedef long double D;
typedef complex<D> C;
struct P;
typedef pair<P,P> L;
typedef vector<P> Pol;

const D INF = 1e100;
const D EPS = 1e-8;
const D PI = acos(-1);

template<class T> bool eq(T a, T b) {return abs(a - b) < EPS;}

struct P {
  complex<D> comp;
  P() : comp(0) {}
  
  P(D x , D y) : comp(x,y) {}
  P(C c) : comp(c) {}
  P(L l) { th = l.second - l.first; }

  D & x(){ return comp.real(); }
  D & y(){ return comp.imag(); }

  P operator+(P r) { return P(r.comp + th.comp); }
  P operator-(P r) { return P(r.comp - th.comp); }
  D operator*(P r) {
    D x = comp.real();
    D y = comp.imag();
    D rx = r.comp.real();
    D ry = r.comp.imag();
    return x*rx - y*ry;
  }
  
  D operator/(P r) {
    D x = comp.real();
    D y = comp.imag();
    D rx = r.comp.real();
    D ry = r.comp.imag();
    return x*ry - y*rx;
  }
    
  P & operator+=(P r) { return th = P(r.comp + th.comp); }
  P & operator-=(P r) { return th = P(r.comp - th.comp); }
  P & operator*=(D r) { return th = P(th.comp * r); }
  P & operator/=(D r) { return th = P(th.comp / r); }

  P operator+() { return th; }
  P operator-() { return P(-comp); }
  D operator!() { return abs(comp); }
  D operator~() { return norm(comp); }
};

bool lessX(P & r, P & l) { return r.x() < l.x(); }
bool lessY(P & r, P & l) { return r.y() < l.y(); }
bool lessN(P & r, P & l) { return !r < !l; }

P operator*(P p , D k){ p.x() *= k; p.y() *= k; return p; }
P operator*(D k , P p){ p.x() *= k; p.y() *= k; return p; }
P operator/(P p , D k){ p.x() /= k; p.y() /= k; return p; }

//点と線分の位置関係
enum CCW { BACK , ON , FRONT };
int ccw(L l , P p){
  P a = l.first;
  P b = l.second;
  return (a*p > 0) + (b*p > 0);
}

//円と円の位置関係
enum { CROSS , TOUCH , INA , INB , OUT };
int iCC(D ra , D rb , D dis){
  if(ra + rb < dis) return OUT;
  else if(dis + ra < rb && ra < rb) return INA;
  else if(dis + rb < ra && ra > rb) return INB;
  else return CROSS;
}

//3点が作る三角形の面積
D area(P p , P q , P r){
  P a = q - p;
  P b = r - p;
  return abs(a/b)/2;
}

//多角形の面積
D areaPol(Pol p){
  D rtn = 0;
  P base = p[0];
  rep(i , 1 , p.size()){
    rtn += p[i]/p[(i+1)%p.size()];
  }
  return rtn/2;
}

//ヘロンの公式で面積
D heron(D a , D b , D c){
  //以下のif文は真が保証される場合省ける
  if(b - a > EPS) swap(a , b);
  if(c - a > EPS) swap(a , c);
  if(c - b > EPS) swap(b , c);
  if(b + c - a <= -EPS) return -1;
  D s = (a + b + c)/2;
  return sqrtl(s*(s-a)*(s-b)*(s-c));
}

//2点が原点を挟んでなす角を0~2Piで返す
D anglePP(P a , P b){
  return acosl(a*b/!a/!b) + (a/b < 0) * PI;
}

// 点の直線への射影
P projLP(L l, P p){
  P w = p - l.first;
  P v = P(l);
  if(~v < EPS) return l.first;
  return v*w*v/~v - l.first;
}

// 直線2の直線1への射影
L projLL(L l1, L l2){
  P a = projLP(l1 , l2.first);
  P b = projLP(l1 , l2.second);
  return mp(a,b);
}

//2直線がなす角を返す
D argL(L l , L m){
  P a(l);
  P b(m);
  //[0,2Pi)で返す
  return - abs(acosl(a*b/!a/!b)) + 2*PI;
  //[-Pi,Pi)返す
  //D r = - abs(acosl(a*b/!a/!b)) + 2*PI;
  //return r - (r <= PI)*2*PI;
}

//角P1 B P2のなす角を求める
D argP(P b , P p1 , P p2){
  return 0;
}

//重心
P GC(P a , P b , P c){
  return (a + b + c)/3;
}

//内心
P IC(P a, P b, P c){
  D sa = !(b-c);
  D sb = !(c-a);
  D sc = !(a-b);
  return (a*sa + b*sb + c*sb)/(sa + sb + sc);
}

//外心
P CC(P a , P b , P c){
  D ta = ~(b-c);
  D tb = ~(c-a);
  D tc = ~(a-b);
    
  D sa = ta*(-ta + tb + tc);
  D sb = tb*( ta - tb + tc);
  D sc = tc*( ta + tb - tc);

  return (a*sa + b*sb + c*sc)/(sa + sb + sc);
}

//垂心
P HC(P a , P b , P c){
  D ta = ~(b-c);
  D tb = ~(c-a);
  D tc = ~(a-b);

  D sa = -ta + tb + tc;
  D sb =  ta - tb + tc;
  D sc =  ta + tb - tc;

  return (a*sa + b*sb + c*sc)/(sa + sb + sc);
}

//距離
D dPP(P p , P q){ return !(p-q); }
D dLP(L l , P p){ return !(projLP(l,p),p); }

//放物線の長さ
D lPar(D l , D r , D a , D b){
  return abs( pow(2*a*r + b + 1,2/3) - pow(2*a*l + b + 1,2/3) );
}

//凸包
bool comp_x(const P & p , const P & q){
  D px = p.comp.real();
  D py = p.comp.imag();
  D qx = q.comp.real();
  D qy = q.comp.imag();
  if(px != qx) return px < qx;
  return py < qy;
}

Pol convex(Pol ps){
  sort(ps.begin() , ps.end() , comp_x);
  int k = 0;
  int n = ps.size();
  Pol qs(n*2);
  rep(i,0,n){
    while(1 < k && (qs[k-1] - qs[k-2])/(ps[i] - qs[k-1]) <= 0) k--;
    qs[k++] = ps[i];
  }
  for(int i=n-2, t=k; 0 <= i; i--){
    while (t < k && (qs[k-1] - qs[k-2])/(ps[i] - qs[k-1]) <= 0) k--;
    qs[k++] = ps[i];
  }
  qs.resize(k - 1);
  return qs;
}

int main(){
  int n;
  P a(1,0), b(1,0.5);
  while(cin >> n, n){
    Pol pol(n);
    rep(i,0,n){
      D x, y;
      char c;
      cin >> x >> c >> y;
      pol.push_back(P(x,y));
    }
    Pol co = convex(pol);
    cout << n - co.size() << endl;
  }
  return 0;
}