#include <bits/stdc++.h>
using namespace std;
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 d) const { return Point(x * d, y * d); }
  bool operator<(const Point &p) const {
    if (x == p.x) return y < p.y;
    return x < p.x;
  }
  bool operator==(const Point &p) const {
    return abs(x - p.x) < 1e-8 && abs(y - p.y) < 1e-8;
  }
  double norm() { return x * x + y * y; }
  bool input() {
    if (cin >> x >> y) return true;
    return false;
  }
};
struct Line {
  Point a, b;
  Line() {}
  Line(Point _a, Point _b) {
    a = _a;
    b = _b;
  }
  bool input() {
    if (a.input() && b.input()) return true;
    return false;
  }
};
struct Circle {
  Point c;
  double r;
  Circle() {}
  Circle(Point _c, double _r) {
    c = _c;
    r = _r;
  }
};
double dot(Point p, Point q) { return p.x * q.x + p.y * q.y; }
double cross(Point p, Point q) { return p.x * q.y - q.x * p.y; }
int ccw(Point a, Point b, Point c) {
  Point v1 = b - a;
  Point v2 = c - a;
  if (cross(v1, v2) > 1e-8) return +1;
  if (cross(v1, v2) < -1e-8) return -1;
  if (dot(v1, v2) < -1e-8) return +2;
  if (v2.norm() - v1.norm() > 1e-8) return -2;
  return 0;
}
Point project(Line s, Point p) {
  Point v1 = s.b - s.a;
  Point v2 = p - s.a;
  double r = dot(v1, v2) / v1.norm();
  return s.a + v1 * r;
}
Point reflect(Line s, Point p) { return p + (project(s, p) - p) * 2.0; }
bool intersect_ll(Line l, Line m) {
  return ccw(l.a, l.b, m.a) * ccw(l.a, l.b, m.b) <= 0 &&
         ccw(m.a, m.b, l.a) * ccw(m.a, m.b, l.b) <= 0;
}
bool crosspoint_ss(Line s, Line t, Point &p) {
  Point a1, a2, b1, b2;
  a1 = s.b - s.a;
  a2 = t.b - t.a;
  b1 = t.a - s.a;
  b2 = s.a - t.b;
  double s1, s2;
  s1 = cross(a1, b1) / 2;
  s2 = cross(a1, b2) / 2;
  if (s1 + s2 < 1e-8) return false;
  p = Point(t.a.x + a2.x * s1 / (s1 + s2), t.a.y + a2.y * s1 / (s1 + s2));
  return true;
}
int crosspoint_ll(Line l, Line m, Point &p) {
  if (intersect_ll(l, m) == false) return 0;
  if (crosspoint_ss(l, m, p) == true) return 1;
  return -1;
}
int crosspoint_cc(Circle c1, Circle c2, Point &p1, Point &p2) {
  double d, a, t;
  d = sqrt((c2.c - c1.c).norm());
  if (abs(c1.c.x - c2.c.x) < 1e-8 && abs(c1.c.y - c2.c.y) < 1e-8 &&
      abs(c1.r - c2.r) < 1e-8)
    return -1;
  if (d < abs(c1.r - c2.r) || c1.r + c2.r < d) return 0;
  a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  t = atan2(c2.c.y - c1.c.y, c2.c.x - c1.c.x);
  p1 = Point(c1.c.x + c1.r * cos(t + a), c1.c.y + c1.r * sin(t + a));
  p2 = Point(c1.c.x + c1.r * cos(t - a), c1.c.y + c1.r * sin(t - a));
  if (abs(p1.x - p2.x) < 1e-8 && abs(p1.y - p2.y) < 1e-8) return 1;
  return 2;
}
int contain_gp(vector<Point> g, Point p) {
  Line l = Line(p, Point(1000000, p.y));
  int cnt = 0, n = g.size();
  for (int i = 0; i < n; i++) {
    Point a = g[i] - p;
    Point b = g[(i + 1) % n] - p;
    if (ccw(g[i], g[(i + 1) % n], p) == 0) return 1;
    if (a.y > b.y) swap(a, b);
    if (a.y <= 1e-8 && 1e-8 < b.y && cross(a, b) > 1e-8) cnt++;
  }
  if ((cnt & 1) == 1) return 2;
  return 0;
}
vector<Point> andrewScan(vector<Point> s) {
  if (s.size() <= 2) return s;
  sort(s.begin(), s.end());
  vector<Point> g;
  for (int i = 0; i < s.size(); i++) {
    for (int n = g.size(); n >= 2 && ccw(g[n - 2], g[n - 1], s[i]) != -1; n--) {
      g.pop_back();
    }
    g.push_back(s[i]);
  }
  int upper_n = g.size();
  for (int i = s.size() - 2; i >= 0; i--) {
    for (int n = g.size(); n > upper_n && ccw(g[n - 2], g[n - 1], s[i]) != -1;
         n--) {
      g.pop_back();
    }
    g.push_back(s[i]);
  }
  reverse(g.begin(), g.end());
  g.pop_back();
  return g;
}
struct Data {
  int n;
  double dist;
  Data() {}
  Data(int _n, double _dist) {
    n = _n;
    dist = _dist;
  }
  bool operator<(const Data &a) const { return dist > a.dist; }
};
struct Edge {
  int to;
  double dist;
  Edge() {}
  Edge(int _to, double _dist) {
    to = _to;
    dist = _dist;
  }
};
int main() {
  int N;
  Circle C[100];
  while (cin >> N, N) {
    for (int i = 0; i < N; i++) {
      scanf("%lf,%lf", &C[i].c.x, &C[i].c.y);
      C[i].r = 1;
    }
    int ans = 0;
    for (int i = 0; i < N; i++) {
      for (int j = i + 1; j < N; j++) {
        Point p[2];
        if (crosspoint_cc(C[i], C[j], p[0], p[1]) > 0) {
          for (int k = 0; k < 2; k++) {
            int cnt = 0;
            for (int l = 0; l < N; l++) {
              if ((C[l].c - p[k]).norm() <= 1 + 1e-8) cnt++;
            }
            ans = max(ans, cnt);
          }
        }
      }
    }
    printf("%d\n", ans);
  }
}
