Go: package main

import (
	"fmt"
	"math"
	"math/cmplx"
)

func main() {
	for {
		var n int
		fmt.Scan(&n)

		if n == 0 {
			return
		}

		arr := make([]complex128, n)

		for i := 0; i < n; i++ {
			var x, y float64

			fmt.Scanf("%f%f", &x, &y)

			arr[i] = complex(x, y)
		}

		max := 1
		for i := 0; i < n; i++ {
			for j := i + 1; j < n; j++ {
				sub := arr[j] - arr[i]

				if cmplx.Abs(sub) >= 2 {
					continue
				}
				sum := arr[j] + arr[i]

				v := 1
				{
					halfd := cmplx.Abs(sub / 2)

					center := sum/2 + sub*cmplx.Rect(math.Sqrt(1-halfd*halfd)/cmplx.Abs(sub), float64(v)*math.Pi/2)

					counter := 0
					for k := 0; k < n; k++ {
						if i == k || j == k || cmplx.Abs(arr[k]-center) <= 1 {
							counter++
						}
					}
					if max < counter {
						max = counter
					}
				}

				v = -1
				{
					halfd := cmplx.Abs(sub / 2)

					center := sum/2 + sub*cmplx.Rect(math.Sqrt(1-halfd*halfd)/cmplx.Abs(sub), float64(v)*math.Pi/2)

					counter := 0
					for k := 0; k < n; k++ {
						if i == k || j == k || cmplx.Abs(arr[k]-center) <= 1 {
							counter++
						}
					}
					if max < counter {
						max = counter
					}
				}

			}
		}

		fmt.Println(max)
	}
}

C++: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>

using namespace std;

#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif

#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))

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

template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }

typedef long long ll;
typedef pair<int, int> pint;

const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };



const double EPS = 1e-8;

struct Rect
{
	double x, y, len;
	int c;
	Rect(double x, double y, double len, int c)
		: x(x), y(y), len(len), c(c) { }
};
bool operator<(const Rect& a, const Rect& b)
{
	return a.c < b.c;
};


int n;
double px[333], py[333];

bool contain(double x, double y, double radius, double xa, double ya)
{
	double dx = x - xa, dy = y - ya;
	return dx*dx + dy*dy < radius*radius + EPS;
}
int count_p(double cx, double cy, double radius)
{
	int res = 0;
	for (int i = 0; i < n; ++i)
		if (contain(cx, cy, radius, px[i], py[i]))
			++res;
	return res;
}

int main()
{
	while (scanf("%d", &n), n)
	{
		rep (i, n)
			scanf("%lf%lf", px + i, py + i);

		int res = 0;
		priority_queue<Rect> q;
		q.push(Rect(0, 0, 10, n));
		while (!q.empty())
		{
			Rect t = q.top(); q.pop();
			if (t.c <= res)
				break;

			double len = t.len / 2;
			double rela_x[] = { 0, len, 0, len };
			double rela_y[] = { 0, 0, len, len };
			rep (i, 4)
			{
				double tx = t.x + rela_x[i], ty = t.y + rela_y[i];
				double cx = tx + len / 2, cy = ty + len / 2;

				max_swap(res, count_p(cx, cy, 1));

				int c = count_p(cx, cy, len * sqrt(2.0) + 1);
				if (c > res)
					q.push(Rect(tx, ty, len, c));
			}
		}
		printf("%d\n", res);
	}
}

C++: #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>

const int MOD = 1e9 + 7;
const int iINF = 1000000000;
const long long int llINF = 1000000000000000000;

using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;

typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
  if (a.first == b.first)
    return a.second < b.second;
  return a.first < b.first;
}
struct multi {
  ll first;
  ll second;
  ll third;
};
bool multicomp(const multi &a, const multi &b) {
  if (a.first == b.first)
    return a.second < b.second;
  return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec)                                                            \
  std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec)                                                            \
  std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VVVL(a, b, c, d)                                                       \
  vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec)                                                            \
  do {                                                                         \
    sort(ALL((vec)));                                                          \
    (vec).erase(std::unique(ALL((vec))), (vec).end());                         \
  } while (0)

ll POW(ll n, ll m) {
  if (m == 0) {
    return 1;
  } else if (m % 2 == 0) {
    ll tmp = POW(n, m / 2);
    return (tmp * tmp);
  } else {
    return (n * POW(n, m - 1));
  }
}

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

long double calc(ll N) {
  vector<long double> X(N, 0), Y(N, 0);
  REP(i, N) cin >> X[i] >> Y[i];
  ll ans = 1;
  REP(i, N - 1) FOR(j, i + 1, N) {
    long double dist2 = DPOW(X[i] - X[j], 2) + DPOW(Y[i] - Y[j], 2);
    if (dist2 >= 4.00001)
      continue;
    long double dist = SQRT(dist2);
    long double cx = (long double)(X[i] + X[j]) / 2;
    long double cy = (long double)(Y[i] + Y[j]) / 2;
    long double kdist = SQRT((long double)1 - (dist2 / 4));

    long double kx1 = cx + ((-Y[i] + Y[j]) * kdist / dist);
    long double ky1 = cy + ((X[i] - X[j]) * kdist / dist);
    long double kx2 = cx - ((-Y[i] + Y[j]) * kdist / dist);
    long double ky2 = cy - ((X[i] - X[j]) * kdist / dist);

    ll ans1 = 0, ans2 = 0;
    REP(k, N) {
      if (DPOW(X[k] - kx1, 2) + DPOW(Y[k] - ky1, 2) <= 1.00001)
        ans1++;
      if (DPOW(X[k] - kx2, 2) + DPOW(Y[k] - ky2, 2) <= 1.00001)
        ans2++;
    }
    ans = max(max(ans1, ans2), ans);
  }
  return ans;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  vl ANS;
  while (true) {
    ll N = 0;
    cin >> N;
    if (N == 0)
      break;
    ANS.push_back(calc(N));
  }

  AUTO(ans, ANS) cout << ans << endl;

  return 0;
}