#include <iostream>
#include <algorithm>
#include <cassert>
#include <vector>
#include <cmath>
#include <stdio.h>

using namespace std;

//-------------------------------------------------------------------------
// geometric library

namespace geometry {

#define EPS 1E-10 ///< 0とみなすサイズ。適当

	struct point {
		double x;
		double y;

		point& operator += (const point& rhs) { x += rhs.x; y += rhs.y; return *this; }
		point& operator -= (const point& rhs) { x -= rhs.x; y -= rhs.y; return *this; }
		point& operator /= (double factor) { x /= factor; y /= factor; return *this; }
		point& operator *= (double factor) { x *= factor; y *= factor; return *this; }
		bool operator == (const point& rhs) const { return (std::abs(x - rhs.x) < EPS) && (std::abs(y - rhs.y) < EPS); }
		bool operator != (const point& rhs) const { return !(*this == rhs); }
		bool operator <= (const point& rhs) const { return x < rhs.x || (x == rhs.x && y <= rhs.y); }
		bool operator >= (const point& rhs) const { return x > rhs.x || (x == rhs.x && y >= rhs.y); }
		bool operator < (const point& rhs) const { return !(*this >= rhs); }
		bool operator > (const point& rhs) const { return !(*this <= rhs); }
	};

	struct circle {
		point center;
		double radius;
	};

	struct line {
		// ax + by + c = 0
		double a;
		double b;
		double c;
	};

	enum rotate_dir {
		rotate_None = 0,
		rotate_CW = 1,
		rotate_CCW = -1
	};

	point operator + (const point& p1, const point& p2)
	{
		point p(p1);
		p += p2;
		return p;
	}

	point operator / (const point& p1, double factor)
	{
		point p(p1);
		p /= factor;
		return p;
	}

	point operator - (const point& p1, const point& p2)
	{
		point p(p1);
		p -= p2;
		return p;
	}

	std::istream& operator >> (std::istream& is, point& p)
	{
		is >> p.x >> p.y;
		return is;
	}

	///! 2点の距離
	double get_distance(const point& p1, const point& p2)
	{
		return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
	}

	///! 2直線の交点
	bool get_crosspoint(const line& l1, const line& l2, point *result)
	{
		double denominator = l1.a * l2.b - l1.b * l2.a;
		if (std::abs(denominator) < EPS) {
			return false;
		}
		result->x = (l1.b * l2.c - l2.b * l1.c) / denominator;
		result->y = (l2.a * l1.c - l1.a * l2.c) / denominator;
		return true;
	}

	///! 2点の垂直2等分線
	bool get_bisector(const point& p1, const point& p2, line *result)
	{
		if (p1 == p2) {
			return false;
		}
		result->a = 2 * (p1.x - p2.x);
		result->b = 2 * (p1.y - p2.y);
		result->c = -(p1.y - p2.y) * (p1.y + p2.y) - (p1.x - p2.x) * (p1.x + p2.x);
		return true;
	}

	bool get_line(const point& p1, const point& p2, line *result)
	{
		if (p1 == p2) {
			return false;
		}
		result->a = p2.y - p1.y;
		result->b = p1.x - p2.x;
		result->c = p1.y * p2.x - p1.x * p2.y;
		return true;
	}

	///! 外接円を求める
	bool get_circum_circle(const point& p1, const point& p2, const point& p3, circle *result)
	{
		double a = get_distance(p1, p2);
		double b = get_distance(p2, p3);
		double c = get_distance(p3, p1);

		// 半径の公式
		result->radius = a * b * c / sqrt((a + b + c) * (-a + b + c) * (a - b + c) * (a + b - c));

		line line_p1p2;
		line line_p2p3;

		// 頂点の垂直2等分線の交点が外心
		return get_bisector(p1, p2, &line_p1p2) &&
			get_bisector(p2, p3, &line_p2p3) &&
			get_crosspoint(line_p1p2, line_p2p3, &result->center);
	}

	double cross_product(const point& p1, const point& p2)
	{
		return p1.x * p2.y - p2.x * p1.y;
	}

	double inner_product(const point& p1, const point& p2)
	{
		return p1.x * p2.x + p1.y * p2.y;
	}

	///! p1-p2-p3が左右どちらの方向に折れているかを判定
	rotate_dir direction(const point& p1, const point& p2, const point& p3)
	{
		point p1_p3 = p1 - p3;
		point p2_p3 = p2 - p3;
		double cross = cross_product(p1_p3, p2_p3);

		if (std::abs(cross) < EPS) {
			return rotate_None;
		}
		else if (cross > 0) {
			return rotate_CW;
		}
		else {
			return rotate_CCW;
		}
	}

	// (p1s, p1e)と(p2s, p2e)の線分交差判定.EPS以下で接している場合はtrue、重なっている場合はfalse
	bool intersect(const point& p1s, const point& p1e, const point& p2s, const point& p2e)
	{
		assert(p1s != p1e && p2s != p2e);
		return
			(direction(p1s, p1e, p2s) != direction(p1s, p1e, p2e)) &&
			(direction(p2s, p2e, p1s) != direction(p2s, p2e, p1e));
	}

	// targetが三角形p1,p2,p3の内部にあるかどうか
	bool is_inside_triangle(const point& p1, const point& p2, const point& p3, const point& target)
	{
		point center_of_gravity = (p1 + p2 + p3) / 3; // 重心

		if (center_of_gravity == target) return true;

		// 重心とtargetを結んだ線分が三角形の辺と交叉するなら、点は三角形の外部にある
		bool intersect_any =
			intersect(p1, p2, center_of_gravity, target) ||
			intersect(p2, p3, center_of_gravity, target) ||
			intersect(p3, p1, center_of_gravity, target);

		return !intersect_any;
	}

	bool is_parallel(const point& p1, const point& p2, const point& p3, const point& p4)
	{
		line l1, l2;
		point cross;

		if (!get_line(p1, p2, &l1) || !get_line(p3, p4, &l2)) {
			return false; // p1-p2, p3-p4で直線が作れない
		}
		return get_crosspoint(l1, l2, &cross) == false;
	}

	bool is_convex(const point* points, int num_points) {
		assert(num_points >= 3);

		rotate_dir base_dir = direction(points[0], points[1], points[2]);
		if (base_dir == rotate_None) {
			return false;
		}

		for (int i = 1; i < num_points; i++) {
			if (direction(points[i], points[(i + 1)%num_points], points[(i + 2)%num_points]) != base_dir) {
				return false;
			}
		}
		return true;
	}

	bool get_convex(const vector<point>& points, vector<point> *convex) {
		if (points.size() < 3) {
			return false;
		}

		vector<point> sorted_points(points);
		int n = 0;
		sort(sorted_points.begin(), sorted_points.end());
		convex->resize(2*sorted_points.size()); // 最大2倍までの数の点が入る

		// 左から右
		for (vector<point>::iterator it = sorted_points.begin(); it != sorted_points.end(); ++it) {
			while (n >= 2 && direction((*convex)[n - 2], (*convex)[n - 1], *it) != rotate_CCW) {
				n--;
			}
			(*convex)[n++] = *it;
		}
		int n_ccw = n;

		// 右から左
		for (vector<point>::reverse_iterator it = sorted_points.rbegin(); it != sorted_points.rend(); ++it) {
			while (n >= n_ccw + 1 && direction((*convex)[n - 2], (*convex)[n - 1], *it) != rotate_CCW) {
				n--;
			}
			(*convex)[n++] = *it;
		}
		n--;// 左端の点が重複するため、最後の点を削除
		convex->resize(n);
		return true;
	}

} // namespace geometry

//-------------------------------------------------------------------------
// solution

using namespace geometry;



int main(void)
{
	int n;
	char sep;
	point pA, pB, pC, pD;

	while (cin >> n) {
		vector<point> points(n), convex;
		for (int i = 0; i < n; i++) {
			cin >> points[i].x >> sep >> points[i].y;
		}

		get_convex(points, &convex);
		cout << (points.size() - convex.size()) << endl;
	}

	return 0;
}