#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
using namespace std;

#define EPS (1e-10)
#define equals(a, b) (fabs((a)-(b)) < EPS )

// Point, Vector class
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 k ){ return Point( x * k, y * k ); }

  double abs() { return sqrt( norm() ); }
  double norm() { return x * x + y * y; }

  bool operator < ( const Point& p ) const {
    return x != p.x ? x < p.x : y < p.y;
  }

  bool operator == ( const Point& p ) const {
    return fabs( x - p.x ) < EPS && fabs( y - p.y ) < EPS;
  }
};
typedef Point Vector;

// Segment
struct Segment {
  Point p1, p2;
};
typedef Segment Line;

double norm( Point p ) {
  return p.x * p.x + p.y * p.y;
}

double abs( Point p ) {
  return sqrt( norm( p ) );
}

double dot( Vector a, Vector b ) {
  return a.x * b.x + a.y * b.y;
}

double cross( Vector a, Vector b ) {
  return a.x * b.y - a.y * b.x;
}

bool isOrthogonal( Vector a, Vector b ) {
  return equals( dot(a, b), 0.0 );
}

bool isOrthogonal( Point a1, Point a2, Point b1, Point b2 ) {
  return isOrthogonal( a1 - a2, b1 - b2 );
}

bool isOrthogonal( Segment s1, Segment s2 ) {
  return equals( dot( s1.p2 - s1.p1, s2.p2 - s2.p1 ), 0.0 );
}

bool isParallel( Vector a, Vector b ) {
  return equals( cross( a, b ), 0.0 );
}

bool isParallel( Point a1, Point a2, Point b1, Point b2 ) {
  return isParallel( a1 - a2, b1 - b2 );
}

bool isParallel( Segment s1, Segment s2 ) {
  return equals( cross( s1.p2-s1.p1, s2.p2 - s2.p1 ), 0.0 );
}

Point project( Segment s, Point p ) {
  Vector base = s.p2 - s.p1;
  double t = dot( p - s.p1, base ) / base.norm();
  return s.p1 + base * t;
}

Point reflect( Segment s, Point p ) {
  return p + ( project( s, p ) - p ) * 2.0;
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw( Point p0, Point p1, 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 ( a.norm() < b.norm() ) return ONLINE_FRONT;
  return ON_SEGMENT;
}

bool isIntersect( Point p1, Point p2, Point p3, Point p4 ) {
  return ( ccw( p1, p2, p3 ) * ccw( p1, p2, p4 ) <= 0 &&
	   ccw( p3, p4, p1 ) * ccw( p3, p4, p2 ) <= 0 );
}

bool isIntersect( Segment s1, Segment s2 ) {
  return isIntersect( s1.p1, s1.p2, s2.p1, s2.p2 );
}

Point getCrossPoint( Segment s1, Segment s2 ) {
  Vector base = s2.p2 - s2.p1;
  double d1 = abs( cross( base, s1.p1 - s2.p1 ) );
  double d2 = abs( cross( base, s1.p2 - s2.p1 ) );
  double t = d1 / ( d1 + d2 );
  return s1.p1 + ( s1.p2 - s1.p1 ) * t;
}

double getDistance( Point a, Point b ) {
  Point c = a - b;
  return c.abs();
}

double getDistanceLP( Line s, Point p ) {
  return abs( cross( s.p2 - s.p1, p - s.p1 ) / abs( s.p2 - s.p1 ) );
}

double getDistanceSP( Segment s, Point p ) {
  Point c1 = p - s.p1;
  Point c2 = p - s.p2;
  if ( dot( s.p2 - s.p1, p - s.p1 ) < 0.0 ) return c1.abs();
  if ( dot( s.p1 - s.p2, p - s.p2 ) < 0.0 ) return c2.abs();
  return getDistanceLP( s, p );
}

double getDistance( Segment s1, Segment s2 ) {
  if ( isIntersect( s1, s2 ) ) return 0.0;
  return min( min( getDistanceSP( s1, s2.p1 ), getDistanceSP( s1, s2.p2 ) ),
	      min( getDistanceSP( s2, s1.p1 ), getDistanceSP( s2, s1.p2 ) ));
}

int main() {
    string line;
    while ( getline( cin, line ) ) {
        istringstream isn( line );
        int n;
        isn >> n;
        if ( n == 0 ) break;
        Point P[101];
        double L[101];
        for ( int i = 0; i < n; i++ ) {
            getline( cin, line );
            replace( line.begin(), line.end(), ',', ' ' );
            istringstream is( line );
            double x, y;
            is >> x >> y;
            P[i].x = x + 1005.0;
            P[i].y = y + 1005.0;
            L[i] = P[i].abs();
        }
        for ( int i = 0; i+1 < n; i++ ) {
            for ( int j = i+1; j < n; j++ ) {
                if ( L[i] > L[j] ) {
                    swap( P[i], P[j] );
                    swap( L[i], L[j] );
                }
            }
        }

        int s = 0, t = n-1;
        int answer = 0;
        bool used[101];
        for ( int i = 0; i < n; i++ ) used[i] = false;
        used[s] = used[t] = true;

        for ( int i = 0; i < n; i++ ) {
            if ( used[i] ) continue;
            for ( int j = 0; j < n; j++ ) {
                if ( used[j] ) continue;
                Vector a( P[s] - P[j] );
                Vector b( P[i] - P[j] );
                Vector c( P[t] - P[j] );
                if ( ( cross( a, b ) > 0 && cross( b, c ) > 0 && cross( c, a ) > 0 ) ||
                     ( cross( a, b ) < 0 && cross( b, c ) < 0 && cross( c, a ) < 0 ) ) {
                    answer++;
                    used[j] = true;
                }
            }
        }

        cout << answer << endl;
    }
    return 0;
}