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 <iostream>
#include <cstdio>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <stack>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <cctype>
#include <complex>
#include <string>
#include <sstream>
#include <fstream>
#include <cassert>
using namespace std;

//common

typedef int  i32;
typedef long long i64,ll;
typedef long double ld;

#define BR "\n"
#define ALL(c) (c).begin(),(c).end()
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,l,r) for(int i=(int)l;i<(int)(r);++i)
#define EACH(it,o) for(auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l,v,r) ((l)<=(v) && (v)<(r))

//config
//#define NDEBUG
//#define INF 1<<30
//#define EPS 1e-8
//const ll MOD =100000007;

//debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp,act)
#define STOP(e)
#else
#define DUMP(x)  cerr << #x << " = " << (x)
#define DUMPLN(x)  DUMP(x) <<endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x)<<endl
#define LINE()    cerr<< " (L" << __LINE__ << ")"
#define LINELN()    LINE()<<endl
#define CHECK(exp,act)  if(exp!=act){DUMPLN(exp);DEBUGLN(act);}
#define STOP(e)  CHECK(e,true);if(!(e)) exit(1);
#endif

template<class T> inline string toString(const vector<T>& x) {
	stringstream ss;
	REP(i,x.size()){
		if(i!=0)ss<<" ";
		ss<< x[i];
	}
	return ss.str();
}

template<class T> inline string toString(const vector<vector<T> >& map) {
	stringstream ss;
	REP(i,map.size()){
		if(i!=0)ss<<BR;
		ss<< toString(map[i]);
	}
	return ss.str();
}
template<class K,class V>  string toString(map<K,V>& x) {
	string res;stringstream ss;
	for(auto& p:x)ss<< p.first<<":" << p.second<<" ";
	return ss.str();
}

string BITtoString(int bit){
    stringstream ss;
    while(bit!=0){ss<<(bit%2);bit/=2;}
    string res=ss.str();reverse(ALL(res));
    return res;
}

template<typename T,typename V> inline T pmod(T v,V MOD){
	return (v%MOD+MOD)%MOD;
}
#define nextInt(n) scanf("%d",&n)
#define defInt(n) int n;nextInt(n)
#define nextLong(n) scanf("%lld",&n)
#define defLong(n) ll n;nextLong(n)
#define nextDouble(n) scanf("%lf",&n)

namespace Ps{
	const double EPS = 1e-8;
	const double INF = 1e12;

	typedef complex<double> P;
	#define X(a) (real(a))
	#define Y(a) (imag(a))
	
	// a×b
	double cross(const P& a,const P& b){
		return imag(conj(a)*b);
	}
	// a・b
	double dot(const P&a,const P& b) {
		return real(conj(a)*b);
	}

	 int ccw(const P& a,P b,P c){
		b -= a; c -= a;
		  if (cross(b,c) > 0)   return +1;       // counter clockwise
		  if (cross(b,c) < 0)   return -1;       // clockwise
		  if (dot(b,c) < 0)     return +2;       // c--a--b on line
		  if (norm(b) < norm(c)) return -2;       // a--b--c on line
		  return 0;
	  }

	  double pfmod(double v,double MOD){
		return fmod(fmod(v,MOD)+MOD,MOD);
	 }
	  double AbsArg(double a){
	  	double ret=pfmod(max(a,-a),2*M_PI);
	  	return min(ret,2*M_PI-ret);
	 }

}
using namespace Ps;



class Main{
	public:

	int N;
	vector<P> ps;
	void run(){
		// ifstream cin("D2");
//		ofstream cout( "D2.out" );
		
		while(true){
			cin >> N;if(N==0)break;
			ps=vector<P>(N);
			REP(i,N){
				double x,y;cin >> x >> y;
				ps[i]=P(x,y);
			} 
			int Mv=1;
			REP(i,N)REP(j,N)if(i!=j){//二点選んで距離1の点を取る
				P dir=(ps[i]-ps[j])*0.5;
				dir*=P(cos(M_PI/2),sin(M_PI/2));
				if(abs(dir)>1)continue;
				P m=(ps[i]+ps[j])*0.5;
				P o=m+dir*(sqrt(1-pow(abs(dir),2))/abs(dir));
				
				int v=0;
				REP(k,N)if(abs(ps[k]-o)<=1+EPS)v++;
				

				Mv=max(Mv,v);
			}
			cout << Mv <<endl;
		}
	}


};
int main(){
	cout <<fixed<<setprecision(15);	
	ios::sync_with_stdio(false);
	Main().run();
	return 0;
}

C++: #include<cstdio>
#include<complex>
 
#define rep(i,n) for(int i=0;i<(n);i++)
 
using namespace std;
 
typedef complex<double> Point;
 
const double EPS=1e-9;
 
int n;
Point p[300];
 
int f(const Point &c){
    int res=0;
    rep(i,n) if(abs(p[i]-c)<1+EPS) res++;
    return res;
}
 
int main(){
    for(;scanf("%d",&n),n;){
        rep(i,n){ double x,y; scanf("%lf%lf",&x,&y); p[i]=Point(x,y); }
 
        int ans=1;
        rep(j,n) rep(i,j) {
            double d=abs(p[j]-p[i])/2;
            Point v=(p[j]-p[i])/(2*d);
            if(d<1){
                ans=max(ans,f(p[i]+d*v+sqrt(1-d*d)*v*Point(0,+1)));
                ans=max(ans,f(p[i]+d*v+sqrt(1-d*d)*v*Point(0,-1)));
            }
        }
        printf("%d\n",ans);
    }
 
    return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;

#define REP(i, n) for (ll (i) = 0 ; (i) < (ll)(n) ; ++(i))
#define REPN(i, m, n) for (ll (i) = m ; (i) < (ll)(n) ; ++(i))
#define REP_REV(i, n) for (ll (i) = (ll)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (ll (i) = (ll)(n) - 1 ; (i) >= m ; --(i))
#define ALL(x) x.begin(), x.end()

//#define INF (1e10)
#define MOD (1000000007)

#define print2D(h, w, arr) REP(i, h) { REP(j, w) cout << arr[i][j] << " "; cout << endl; }
template<class T> void print(const T& x) { cout << x << endl; }
template<class T, class... A> void print(const T& first, const A& ... rest) { cout << first << " "; prll(rest...); }
struct PreMain { PreMain() { cin.tie(0); ios::sync_with_stdio(false); } } premain;

double eps = 1e-7;
double inf = 1e10;


#define N_MAX	(300)
double X[N_MAX];
double Y[N_MAX];

int main() {
	while (true) {
		int N;
		cin >> N;

		if (0 == N) {
			break;
		}

		//input
		REP(i, N) {
			cin >> X[i] >> Y[i];
		}

		int ans = 1;

		//problem
		//2点を通る単位円に含まれる点を数える
		REP(i, N) REP(j, N) {
			if (i == j) continue;
			double dx = (X[i] - X[j]);
			double dy = (Y[i] - Y[j]);
			double d2 = (dx * dx) + (dy * dy);
			double d = sqrt(d2);
			if ((2.0 + eps) < d) continue;

			double v = sqrt(1.0 - (d2 / 4));
			double cx = (X[i] + X[j]) / 2 - (v * dy / d);
			double cy = (Y[i] + Y[j]) / 2 + (v * dx / d);
			
			int cnt = 0;
			REP(k, N) {
				double tmpx = (X[k] - cx);
				double tmpy = (Y[k] - cy);
				if ((tmpx * tmpx) + (tmpy * tmpy) < (1.0 + eps)) {
					cnt++;
				}
			}
			if (ans < cnt) {
				ans = cnt;
			}
		}

		print(ans);
	}
	return 0;
}