#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
// ------ Classes ------ //
class Point {
public:
    long double px, py;
    Point() : px(0), py(0) {};
    Point(long double px_, long double py_) : px(px_), py(py_) {};
    bool operator==(const Point& p) const { return px == p.px && py == p.py; }
    bool operator!=(const Point& p) const { return px != p.px || py != p.py; }
    bool operator<(const Point& p) const { return px < p.px ? true : (px == p.px && py < p.py); }
    bool operator>(const Point& p) const { return px > p.px ? true : (px == p.px && py > p.py); }
    bool operator<=(const Point& p) const { return !(Point(px, py) > p); }
    bool operator>=(const Point& p) const { return !(Point(px, py) < p); }
    Point operator+(const Point& p) const { return Point(px + p.px, py + p.py); }
    Point operator-(const Point& p) const { return Point(px - p.px, py - p.py); }
    Point operator/(long double d) const { return Point(px / d, py / d); }
    friend Point operator*(const Point p, long double d) { return Point(p.px * d, p.py * d); }
    friend Point operator*(long double d, const Point& p) { return p * d; }
    Point& operator+=(const Point& p1) { px += p1.px, py += p1.py; return *this; }
    Point& operator-=(const Point& p1) { px -= p1.px, py -= p1.py; return *this; }
    Point& operator*=(long double d) { px *= d, py *= d; return *this; }
    Point& operator/=(long double d) { px /= d, py /= d; return *this; }
};
class Circle {
public:
    Point p; long double r;
    Circle() : p(Point()), r(0.0L) {};
    Circle(Point p_) : p(p_), r(0.0L) {};
    Circle(Point p_, long double r_) : p(p_), r(r_) {};
    Circle(long double x_, long double y_) : p(Point(x_, y_)), r(0.0L) {};
    Circle(long double x_, long double y_, long double r_) : p(Point(x_, y_)), r(r_) {};
    bool operator==(const Circle& c) const { return p == c.p && r == c.r; }
    bool operator!=(const Circle& c) const { return !(Circle(p, r) == c); }
};
 
// ------ Functions ------ //
long double norm(const Point& a) { return a.px * a.px + a.py * a.py; }
long double abs(const Point& a) { return sqrtl(norm(a)); }
long double arg(const Point& a) { return atan2l(a.py, a.px); }
long double dot(const Point& a, const Point& b) { return a.px * b.px + a.py * b.py; }
long double crs(const Point& a, const Point& b) { return a.px * b.py - a.py * b.px; }
Point pol(long double r, long double d) { return Point(cosl(d) * r, sinl(d) * r); }
int ccw(const Point& p0, const Point& p1, const Point& p2) {
    Point a = p1 - p0, b = p2 - p0;
    if (crs(a, b) > 1e-10) return 1;
    if (crs(a, b) < -1e-10) return -1;
    if (dot(a, b) < -1e-10) return 2;
    if (norm(a) < norm(b)) return -2;
    return 0;
}
bool its(const Point& p1, const Point& p2, const Point& p3, const Point& p4) { return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0); }
long double dst(const Point& a, const Point& b) { return abs(b - a); }
vector<Point> crp(Circle c1, Circle c2) {
    double d = abs(c1.p - c2.p);
    double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
    double t = arg(c2.p - c1.p);
    return { c1.p + pol(c1.r, t + a), c1.p + pol(c1.r, t - a) };
}
 
// ------ Main ------ //
int n; char c; vector<Circle> v;
int main() {
    while (cin >> n, n) {
        v.resize(n);
        for (int i = 0; i < n; i++) cin >> v[i].p.px >> c >> v[i].p.py, v[i].r = 1;
        int ret = 1;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (dst(v[i].p, v[j].p) > 2.0L + 1e-10) continue;
                vector<Point> w = crp(v[i], v[j]);
                for (int k = 0; k < 2; k++) {
                    int s = 0;
                    for (int l = 0; l < n; l++) {
                        if (dst(w[k], v[l].p) <= 1.0L + 1e-10) s++;
                    }
                    ret = max(ret, s);
                }
            }
        }
        cout << ret << endl;
    }
}

Measured memory_bytes: 3476