#include <iostream>
#include <vector>
#include <algorithm>

#define EPS 1e-10

struct POINT_DOUBLE {
  double x;
  double y;

  bool operator == (const POINT_DOUBLE& other) const {
    return (std::abs(x - other.x) < EPS) && (std::abs(y - other.y) < EPS);
  }

  bool operator < (const POINT_DOUBLE& other) const {
    return x < other.x || (x == other.x && y < other.y);
  }
};

struct LINE_DOUBLE {
  LINE_DOUBLE() {}
  LINE_DOUBLE(const POINT_DOUBLE& pt1, const POINT_DOUBLE& pt2) {
    a = pt1.y - pt2.y;
    b = pt2.x - pt1.x;
    c = pt1.x * pt2.y - pt2.x * pt1.y;
  }

  double GetValue(const POINT_DOUBLE& pt) {
    return a * pt.x + b * pt.y + c;
  }

  double a;
  double b;
  double c;
};

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

bool getConvex(const std::vector<POINT_DOUBLE>& pts, std::vector<POINT_DOUBLE>* pConvex)
{
  if (pts.size() <= 2) {
    return false;
  }

  std::vector<POINT_DOUBLE> sorted;
  sorted.assign(pts.begin(), pts.end());
  std::sort(sorted.begin(), sorted.end());

  pConvex->clear();
  pConvex->push_back(*sorted.begin());

  while (1) {
    POINT_DOUBLE ref = *pConvex->rbegin();

    for (auto pt1 : sorted) {
      if (pt1 == ref) {
        continue;
      }
      LINE_DOUBLE line(ref, pt1);
      bool bOuterMost = true;
      for (auto pt2 : sorted) {
        if (pt2 == ref || pt2 == pt1) {
          continue;
        }
        if (line.GetValue(pt2) < 0) {
          bOuterMost = false;
        }
      }

      if (bOuterMost) {
        pConvex->push_back(pt1);
        break;
      }
    }

    if (pConvex->at(0) == *pConvex->rbegin()) {
      pConvex->pop_back();
      break;
    }
  }

  return true;
}

int main(void)
{
  char c;
  int n;

  while (1) {
    std::cin >> n;
    if (n == 0) {
      break;
    }
    std::vector<POINT_DOUBLE> pts(n);
    for (int i = 0; i < n; i++) {
      std::cin >> pts.at(i).x >> c >> pts.at(i).y;
    }
    std::vector<POINT_DOUBLE> convex;
    getConvex(pts, &convex);
    std::cout << pts.size() - convex.size() << std::endl;
  }

  return 0;
}

