#include <bits/stdc++.h>
using namespace std;

#define rep(i,n) for(int i=0;i<(n);++i)
#define loop for(;;)
#define inf (1e9)
#define eps (1e-9)
#define trace(var) cerr<<">>> "<<#var<<" = "<<var<<endl;
typedef long long Integer;
typedef long double Real;
typedef pair<Real, Real> P; // Point
typedef pair<P, P> L; // segment or line
const Real PI = acos(-1);

template<class S, class T> inline
ostream& operator<<(ostream&os, pair<S,T> p) {
  os << '(' << p.first << ", " << p.second << ')';
  return os;
}

template<class T> inline
ostream& operator<<(ostream&os, vector<T> v) {
  if (v.size() == 0) {
    os << "(empty)";
    return os;
  }
  os << v[0];
  for (int i=1, len=v.size(); i<len; ++i) os << ' ' << v[i];
  return os;
}

template<class T> inline
istream& operator>>(istream&is, vector<T>&v) {
  rep (i, v.size()) is >> v[i];
  return is;
}

int dx[] = { -1, 0, 1, 0 };
int dy[] = {  0, -1, 0, 1 };

/* inner dot */
Real dot(P&a, P&b) {
  return a.first * b.first + a.second * b.second;
}
Real operator*(P&a, P&b) {
  return a.first * b.first + a.second * b.second;
}

/* scalar multiple */
P operator*(P a, Real c) {
  return {c * a.first, c * a.second};
}
P operator*(Real c, P a) {
  return {c * a.first, c * a.second};
}

P operator/(P a, Real d) {
  return {a.first / d, a.second / d};
}

Real det(P a, P b) {
  return a.first * b.second - a.second * b.first;
}

/* vector operator */
P operator+(P a, P b) {
  return {a.first + b.first, a.second + b.second};
}

P operator-(P a) {
  return {-a.first, -a.second};
}

P operator-(P a, P b) {
  return {a.first - b.first, a.second - b.second};
}

/* distance */
Real Manhattan(P a, P b) {
  return abs(a.first - b.first) + abs(a.second - b.second);
}
Real Euclidean(P a, P b) {
  P p = a - b;
  return sqrt(p.first*p.first + p.second*p.second);
}

/* equality with eps (default: 1e-9) */
bool eq(Real x, Real y) {
  return abs(x - y) < eps;
}
bool operator==(P a, P b) {
  return eq(a.first, b.first) && eq(a.second, b.second);
}

int sign(Real a) {
  if (eq(a, 0)) return 0;
  return a > 0 ? 1 : -1;
}

Real magnitude(P p) {
  return sqrt(p.first*p.first + p.second*p.second);
}

Real arg(P a, P b) {
  Real x = dot(a, b) / magnitude(a) / magnitude(b);
  x = min<Real>(1, max<Real>(-1, x));
  return acos(x);
}

vector<P> covex_hull(vector<P> ps) {
  sort(begin(ps), end(ps));
  const int n = ps.size();
  vector<P> top, bot;
  { // top-hull
    rep (i, n) {
      while (true) {
        int m = top.size();
        if (m > 1 and det(ps[i] - top[m-2], top[m-1] - top[m-2]) >= 0) {
          top.pop_back();
        } else break;
      }
      top.push_back(ps[i]);
    }
  }
  { // bottom-hull
    rep (i, n) ps[i].second *= -1;
    sort(begin(ps), end(ps));
    rep (i, n) {
      while (true) {
        int m = bot.size();
        if (m > 1 and det(ps[i] - bot[m-2], bot[m-1] - bot[m-2]) >= 0) {
          bot.pop_back();
        } else break;
      }
      bot.push_back(ps[i]);
    }
    for (P&p: bot) p.second *= -1;
  }
  // trace(top); trace(bot);
  vector<P> ret;
  { // merge
    for (auto&p: top) ret.push_back(p);
    for (auto&p: bot) ret.push_back(p);
    sort(begin(ret), end(ret));
    ret.erase(unique(begin(ret), end(ret)), end(ret));
  }
  return ret;
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout.setf(ios::fixed);
  cout.precision(10);

  loop {
    int n; cin >> n;
    if (n == 0) break;
    vector<P> ps;
    rep (i, n) {
      Real x, y; char comma;
      cin >> x >> comma >> y;
      ps.push_back(P(x, y));
    }
    cout << (ps.size() - covex_hull(ps).size()) << endl;
    
  }

  return 0;
}

Measured memory_bytes: 1252