// Original C++ solution (slower):
#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<cmath>

#include<cassert>

#include<iostream>

#include<sstream>

#include<string>

#include<vector>

#include<queue>

#include<set>

#include<map>

#include<utility>

#include<numeric>

#include<algorithm>

#include<bitset>

#include<complex>

#include<stack>



using namespace std;



typedef long long Int;

typedef vector<int> vint;

typedef pair<int,int> pint;

typedef vector<string> vstring;

typedef vector<pint> vpint;

typedef stringstream SS;



template<class T> void chmin(T &t, T f) { if (t > f) t = f; }

template<class T> void chmax(T &t, T f) { if (t < f) t = f; }



#define rep(i,n) for(int i=0;i<(n);++i)

#define repn(i,m,n) for(int i=(m);i<(n);++i)

#define repd(i,n) for(int i=(n)-1;i>=0;--i)

#define repnd(i,m,n) for(int i=(n)-1;i>=(m);--i)

#define rep0(i,n) for(i=0;i<(n);++i)

#define repn0(i,m,n) for(i=(m);i<(n);++i)

#define repd0(i,n) for(i=(n)-1;i>=0;--i)

#define repnd0(i,m,n) for(i=(n)-1;i>=(m);--i)

#define repc(i,n) for(int i=0;i<=(n);++i)

#define repcn(i,m,n) for(int i=(m);i<=(n);++i)

#define repcd(i,n) for(int i=(n);i>=0;--i)

#define repcnd(i,m,n) for(int i=(n);i>=(m);--i)

#define repc0(i,n) for(i=0;i<=(n);++i)

#define repcn0(i,m,n) for(i=(m);i<=(n);++i)

#define repcd0(i,n) for(i=(n);i>=0;--i)

#define repcnd0(i,m,n) for(i=(n);i>=(m);--i)

#define all(n) n.begin(),n.end()

#define sz(n) ((int)(n).size())

#define IL for(;;)

#define MP make_pair

#define PB push_back

#define X second

#define Y first

#define p_queue(n) priority_queue<n,vector<n>,greater<n> >

#define PUTLINE cout<<"LINE:"<<__LINE__<<endl;



const int INF = 2147483647/3;

const double EPS = 1e-7;

const double PI = acos(-1.0);



const int dx[]={1,-1,0,0,1,1,-1,-1,0};

const int dy[]={0,0,1,-1,1,-1,1,-1,0};



int sig(double r) { return r < -EPS ? -1 : r > EPS ? 1 : 0; }



struct P {

	double x, y;

	P() {}

	P(double x, double y) : x(x), y(y) {}

	P operator+(const P &a) const { return P(x + a.x, y + a.y); }

	P operator-(const P &a) const { return P(x - a.x, y - a.y); }

	P operator*(const P &a) const { return P(x * a.x - y * a.y, x * a.y + y * a.x); }

	P operator-() const { return P(-x, -y); }

	P operator*(const double &k) const { return P(x * k, y * k); }

	P operator/(const double &k) const { return P(x / k, y / k); }

	double abs2() const { return x * x + y * y; }

	double abs() const { return sqrt(abs2()); }

	double arg() const { return atan2(y, x); }

	double dot(const P &a) const { return x * a.x + y * a.y; }

	double det(const P &a) const { return x * a.y - y * a.x; }

	P proj(const P &a) const { double k = dot(a) / abs2(); return P(x * k, y * k); }

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

	bool operator==(const P &a) const { return sig(x - a.x) == 0 && sig(y - a.y) == 0; }

};



ostream &operator<<(ostream&os, const P&a) { os << "(" << a.x << ", " << a.y << ")"; return os; }

double tri(P a, P b, P c) { return (b - a).det(c - a); }



struct L {

	P a, b;

	L() {}

	L(P a, P b) : a(a), b(b) {}

	P vec() const { return b - a; }

	P proj(const P &p) const { return a + vec().proj(p - a); }

	P refl(const P &p) const { return proj(p) * 2 - p; }

	int iSP(const P &p) const {

		int s = sig(vec().det(p - a));

		if (s != 0) return s;

		if (sig(vec().dot(p - a)) < 0) return -2;

		if (sig(-vec().dot(p - b)) < 0) return 2;

		return 0;

	}

	int iLL(const L &l) const {

		if (sig(vec().det(l.vec()))) return 1;

		if (sig(vec().det(l.a - a))) return 0;

		return -1;

	}

	bool iLS(const L &l) const { return sig(tri(a, b, l.a)) * sig(tri(a, b, l.b)) <= 0; }

	bool iSS(const L &l) const { return this->iSP(l.a) * this->iSP(l.b) <= 0 && l.iSP(a) * l.iSP(b) <=0; }

	P pLL(const L &l) const { return a + vec() * (l.a - a).det(l.vec()) / b.det(l.vec()); }

	double dLP(const P &p) const { return abs(tri(a, b, p)) / vec().abs(); }

	double dSP(const P &p) const {

		if (sig(vec().dot(p - a)) <= 0) return (p - a).abs();

		if (sig(vec().dot(p - b)) >= 0) return (p - b).abs();

		return dLP(p);

	}

	double dLL(const L &l) const { return iLL(l) ? 0 : dLP(l.a); }

	double dLS(const L &l) const { return iLS(l) ? 0 : min(dLP(l.a), dLP(l.b)); }

	double dSS(const L &l) const { return iSS(l) ? 0 : min(min(dSP(l.a), dSP(l.b)), min(l.dSP(a), l.dSP(b))); }

};



P p[310];



int main() {

	int n, res;

	IL {

		cin >> n;

		if (n == 0) break;

		res = 1;

		rep (i, n) cin >> p[i].x >> p[i].y;

		rep (i, n) repn (j, i + 1, n) {

			if (sig((p[i] - p[j]).abs() - 2) > 0) continue;

			P v = p[j] - p[i];

			double th = acos(v.abs() / 2);

			P c = p[i] + P(cos(v.arg() + th), sin(v.arg() + th));

			int r = 0;

			rep (k, n) {

				if (sig((p[k] - c).abs() - 1) <= 0) ++r;

			}

			res = max(res, r);

			c = p[i] + P(cos(v.arg() - th), sin(v.arg() - th));

			r = 0;

			rep (k, n) {

				if (sig((p[k] - c).abs() - 1) <= 0) ++r;

			}

			res = max(res, r);

		}

		cout << res << endl;

	}

	return 0;

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<cmath>



using namespace std;



#define rep(i, n) for (int i = 0; i < int(n); ++i)



double x[400], y[400];



double EPS = 1e-8;



int main() {

  int n;

  for (;;) {

    cin >> n;

    if (n == 0) break;

    int res = 1;

    rep (i, n) cin >> x[i] >> y[i];

    rep (i, n) rep (j, n) if (i < j && sqrt(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2)) <= 2 + EPS) {

      double mx = (x[i] + x[j]) / 2, my = (y[i] + y[j]) / 2;

      double nx = -(my - y[i]), ny = (mx - x[i]);

      double d = sqrt(max(1 - (pow(x[i] - mx, 2) + pow(y[i] - my, 2)), 0.));

      double dx = nx / sqrt(nx * nx + ny * ny) * d;

      double dy = ny / sqrt(nx * nx + ny * ny) * d;

      double xx = mx + dx, yy = my + dy;

      //cout << i <<  " " << j << endl;

      //cout << d << endl;

      //cout << dx << " " << dy << endl;

      //cout << xx << " " << yy << endl;

      int count = 0;

      rep (k, n) {

	//cout << pow(x[k] - xx, 2) + pow(y[k] - yy, 2) << endl;

	if (pow(x[k] - xx, 2) + pow(y[k] - yy, 2) <= 1 + EPS * 10) ++count;

      }

      res = max(res, count);

      xx = mx - dx, yy = mx - dy;

      count = 0;

      rep (k, n) {

	//cout << pow(x[k] - xx, 2) + pow(y[k] - yy, 2) << endl;

	if (pow(x[k] - xx, 2) + pow(y[k] - yy, 2) <= 1 + EPS * 10) ++count;

      }

      res = max(res, count);

    }

    cout << res << endl;

  }

}

// Fastest known solution for this problem: