#include <bits/stdc++.h>

using namespace std;

#define EPS 1e-10
 
struct Point {
    double x, y;
 
    Point(){}
    Point(double x, double y) : x(x), y(y) {}
 
    Point operator + (const Point &p)const{ return Point(x+p.x,y+p.y); }
    Point operator - (const Point &p)const{ return Point(x-p.x,y-p.y); }
    Point operator * (const double &k)const{ return Point(x*k,y*k); }
};
 
double dot(const Point &a, const Point &b)
{
    return a.x * b.x + a.y * b.y;
}
 
double cross(const Point &a, const Point &b)
{
    return a.x * b.y - b.x * a.y;
}
 
double norm(const Point &p)
{
    return dot(p, p);
}
 
#define COUNTER_CLOCKWISE +1
#define CLOCKWISE         -1
#define ONLINE_BACK       +2
#define ONLINE_FRONT      -2
#define ON_SEGMENT        +0
typedef Point Vector;
 
int ccw(const Point &p0, const Point &p1, const Point &p2)
{
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
    if (cross(a, b) < -EPS) return CLOCKWISE;
    if (dot(a, b) < -EPS) return ONLINE_BACK;
    if (norm(a) < norm(b)) return ONLINE_FRONT;
    return ON_SEGMENT;
}
 
typedef vector<Point> Polygon;
 
bool sortY(Point p1, Point p2)
{
    if (p1.y != p2.y) {
    return (p1.y - p2.y < -EPS);
    } else { 
    return (p1.x - p2.x < -EPS);
    }
}
 
Polygon convex_hull(Polygon &ps)
{
    int N = ps.size(), j = 0;
    Polygon pg(N*2);
    sort(ps.begin(), ps.end(), sortY);
    for (int i = 0; i < N; i++, j++) {
    while (j >= 2 && ccw(pg[j-2], pg[j-1], ps[i]) == -1) {
        j--;
    }
    pg[j] = ps[i];
    }
    int k = j+1;
    for (int i = N-2; i >= 0; i--, j++) {
    while (j >= k && ccw(pg[j-2], pg[j-1], ps[i]) == -1) {
        j--;
    }
    pg[j] = ps[i];
    }
    pg.resize(j-1);
    return pg;
}
 
int main()
{
    int N;
    char c;
    while (cin >> N, N) {
        Polygon pg(N);
        for (int i = 0; i < N; i++) {
            cin >> pg[i].x >> c >> pg[i].y;
        }        
        cout << N - convex_hull(pg).size() << endl;
    }
    return 0;
}