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


constexpr double PI = 3.14159265358979323846264338327950288;
constexpr double EPS = 1e-10;


//COUNTER CLOCKWISE
constexpr int CCW_COUNTER_CLOCKWISE = 1;
constexpr int CCW_CLOCKWISE = -1;
constexpr int CCW_ONLINE_BACK = 2;
constexpr int CCW_ONLINE_FRONT = -2;
constexpr int CCW_ON_SEGMENT = 0;


//CIRCLE INTERSECTION
constexpr int ICC_SEPARATE = 4;
constexpr int ICC_CIRCUMSCRIBE = 3;
constexpr int ICC_INTERSECT = 2;
constexpr int ICC_INSCRIBE = 1;
constexpr int ICC_CONTAIN = 0;


inline bool eq(const double a, const double b){ return fabs(a-b) < EPS; }


//Point
struct Point {
    double x, y;
    Point() = default;
    Point(double x, double y) : x(x), y(y){}
    friend ostream& operator<<(ostream& os, const Point& p){ return os << '(' << p.x << ", " << p.y << ')'; }
    friend istream& operator>>(istream& is, Point& p){ return is >> p.x >> p.y; }
};
using Vector = Point;
inline Vector operator+(const Vector& p, const Vector& q){ return Vector(p.x+q.x, p.y+q.y); }
inline Vector operator-(const Vector& p, const Vector& q){ return Vector(p.x-q.x, p.y-q.y); }
inline Vector operator*(const Vector& p, double a){ return Vector(p.x*a, p.y*a); }
inline Vector operator*(double a, const Vector& p){ return Vector(a*p.x, a*p.y); }
inline Vector operator/(const Vector& p, double a){ return Vector(p.x/a, p.y/a); }
inline Vector conj(const Vector& p){ return Vector(p.x, -p.y); }
inline Vector rot(const Vector& p, double ang){ return Vector(cos(ang)*p.x-sin(ang)*p.y, sin(ang)*p.x+cos(ang)*p.y); }
inline Vector rot90(const Vector& p){ return Vector(-p.y, p.x); }
inline double dot(const Vector& p, const Vector& q){ return p.x*q.x+p.y*q.y; }
inline double det(const Vector& p, const Vector& q){ return p.x*q.y-p.y*q.x; }
inline double norm(const Vector& p){ return p.x*p.x+p.y*p.y; }
inline double abs(const Vector& p){ return sqrtl(norm(p)); }
inline double amp(const Vector& p){ double res = atan2(p.y, p.x); if(res < 0) res+=PI*2; return res; }
inline bool eq(const Vector& p, const Vector& q){ return abs(p-q) < EPS; }
inline bool operator<(const Vector& p, const Vector& q){ return (!eq(p.x, q.x) ? p.x < q.x : p.y < q.y); }
inline bool operator>(const Vector &p, const Vector &q){ return (!eq(p.x, q.x) ? p.x > q.x : p.y > q.y); }


using Polygon = vector<Point>;
istream& operator>>(istream& is, Polygon& p){ for(int i = 0;i < (int)p.size();++i) is >> p[i]; return is; }


// Segment
struct Segment{
    Point p1, p2;
    Segment() = default;
    Segment(Point p1, Point p2) : p1(p1), p2(p2){}
    Segment(double x1, double y1, double x2, double y2) : p1(x1, y1), p2(x2, y2){}
    const Point& operator[](bool i) const { return i ? p2 : p1; }
    Point& operator[](bool i){ return i ? p2 : p1; }
    friend ostream& operator<<(ostream& os, const Segment& l){ return os << '{' << l[0] << ", " << l[1] << '}'; }
    friend istream& operator>>(istream& is, Segment& l){ return is >> l.p1 >> l.p2; }
};
using Line = Segment;


//Circle
struct Circle {
    Point c;
    double r;
    Circle() = default;
    Circle(Point c, double r) : c(c), r(r){}
    friend istream& operator>>(istream& is, Circle& c){ return is >> c.c >> c.r; }
};


bool isOrthogonal(const Vector& a, const Vector& b){
    return eq(dot(a, b), 0.0);
}


bool isOrthogonal(const Segment& s1, const Segment& s2){
    return eq(dot(s1[1]-s1[0], s2[1]-s2[0]), 0.0);
}


bool isParallel(const Vector& a, const Vector& b){
    return eq(det(a, b), 0.0);
}


bool isParalell(const Segment& s1, const Segment& s2){
    return eq(det(s1[1]-s1[0], s2[1]-s2[0]), 0.0);
}


Point project(const Line& l, const Point& p){
    return (l[1]-l[0])*dot(l[1]-l[0], p-l[0])/norm(l[1]-l[0]);
}


Point reflect(const Line& l, const Point& p){
    return p+(project(l, p)-p)*2;
}


Vector polar(double r, double ang){
    return Point(r*cos(ang), r*sin(ang));
}


int ccw(const Point& a, const Point& b, const Point& c);
bool intersectSS(const Segment& s1, const Segment& s2);
bool intersectPS(const Polygon& p, const Segment& s);
int intersectCC(const Circle& c1, const Circle& c2);
bool intersectSC(const Segment& s, const Circle& c);
double getDistanceLP(const Line& l, const Point& p);
double getDistanceSP(const Segment& s, const Point& p);
Point getCrossPointSS(const Segment& s1, const Segment& s2);
Point getCrossPointLL(const Line& l1, const Line& l2);
Polygon getCrossPointCL(const Circle& c, const Line& l);
Polygon getCrossPointCC(const Circle& c1, const Circle& c2);
Polygon convexHull(Polygon ps);
Circle circumcircle(const Point& a, const Point& b, const Point& c);


int ccw(const Point& a, const Point& b, const Point& c){
    if(det(b-a, c-a) > EPS) return CCW_COUNTER_CLOCKWISE;
    if(det(b-a, c-a) < -EPS) return CCW_CLOCKWISE;
    if(dot(b-a, c-a) < -EPS) return CCW_ONLINE_BACK;
    if(norm(b-a) < norm(c-a)) return CCW_ONLINE_FRONT;
    return CCW_ON_SEGMENT;
}


bool intersectSS(const Segment& s1, const Segment& s2){
    return (ccw(s1[0], s1[1], s2[0])*ccw(s1[0], s1[1], s2[1]) <= 0 and ccw(s2[0], s2[1], s1[0])*ccw(s2[0], s2[1], s1[1]) <= 0);
}


double getDistanceLP(const Line& l, const Point& p){
    return abs(det(l[1]-l[0], p-l[0])/abs(l[1]-l[0]));
}


double getDistanceSP(const Segment& s, const Point& p){
    if(dot(s[1]-s[0], p-s[0]) < 0.0) return abs(p-s[0]);
    if(dot(s[0]-s[1], p-s[1]) < 0.0) return abs(p-s[1]);
    return getDistanceLP(s, p);
}


Point getCrossPointSS(const Segment& s1, const Segment& s2){
    for(int i = 0;i < 2;++i){
        if(getDistanceSP(s1, s2[i]) < EPS) return s1[i];
        if(getDistanceSP(s2, s1[i]) < EPS) return s2[i];
    }
    double d1 = abs(det(s2[1]-s2[0], s1[0]-s2[0]));
    double d2 = abs(det(s2[1]-s2[0], s1[1]-s2[0]));
    return s1[0]+(s1[1]-s1[0])*d1/(d1+d2);
}


Point getCrossPointLL(const Line& l1, const Line& l2){
    double a = det(l1[1]-l1[0], l2[1]-l2[0]);
    double b = det(l1[1]-l1[0], l1[1]-l2[0]);
    if(abs(a) < EPS and abs(b) < EPS) return l2[0];
    return l2[0]+(l2[1]-l2[0])*b/a;
}


Polygon convexHull(Polygon ps){
    int n = ps.size();
    sort(begin(ps), end(ps));
    int k = 0;
    Polygon qs(2*n);
    for(int i = 0;i < n;++i){
        while(k > 1 and det(qs[k-1]-qs[k-2], ps[i]-qs[k-2]) < 0) --k;
        qs[k++] = ps[i];
    }
    for(int i = n-2, t = k;i >= 0;--i){
        while(k > t and det(qs[k-1]-qs[k-2], ps[i]-qs[k-2]) < 0) --k;
        qs[k++] = ps[i];
    }
    qs.resize(k-1);
    return qs;
}


bool compArg(const Point& a, const Point& b){
    auto getA = [&](Point p){
        if(p.x >= 0 and p.y >= 0) return 0;
        if(p.y >= 0) return 1;
        if(p.x <= 0) return -2;
        return -1;
    };
    if(getA(a) != getA(b)) return getA(a) < getA(b);
    if(a.x == 0 and a.y == 0) return !(b.x == 0 and b.y == 0);
    if(b.x == 0 and b.y == 0) return false;
    return det(a, b) > 0;
}


int main(){
    int n;
    while(cin >> n, n){
        Polygon ps(n);
        string s;
        stringstream ss;
        for(int i = 0;i < n;++i){
            cin >> s;
            replace(begin(s), end(s), ',', ' ');
            ss << s;
            ss >> ps[i];
            ss.clear();
        }
        cout << n-convexHull(ps).size() << endl;
    }

    return 0;
}
