Problem:
 Problem D: Circle and Points You are given N points in the xy -plane. You have a
circle of radius one and move it on the xy -plane, so as to
enclose as many of the points as possible. Find how many points can be
simultaneously enclosed at the maximum. A point is considered enclosed by a circle when it is inside or on the circle.   Fig 1. Circle and Points  Input The input consists of a series of data sets, followed by a single line
only containing a single character '0', which indicates the end of the
input.  Each data set begins with a line containing an integer N ,
which indicates the number of points in the data set. It is
followed by N lines describing the coordinates of the
points. Each of the N lines has two decimal fractions X and Y , describing the x - and y -coordinates of a
point, respectively. They are given with five digits after the decimal
point. You may assume 1 <= N <= 300,  0.0 <= X <= 10.0, and 0.0
<= Y <= 10.0. No two points are closer than 0.0001.  No two
points in a data set are approximately at a distance of 2.0. More
precisely, for any two points in a data set, the distance d between the two never satisfies 1.9999 <= d <= 2.0001. Finally,
no three points in a data set are simultaneously very close to a
single circle of radius one. More precisely,
let P 1 , P 2 , and P 3 be any three points in a
data set, and d 1 , d 2 , and d 3 the distances from an arbitrarily selected point in the xy -plane to each of them
respectively. Then it never simultaneously holds that 0.9999 <= d i <= 1.0001 ( i = 1, 2, 3). Output For each data set, print a single line containing the maximum number
of points in the data set that can be simultaneously enclosed by a
circle of radius one. No other characters including leading and
trailing spaces should be printed. Sample Input 3
6.47634 7.69628
5.16828 4.79915
6.69533 6.20378
6
7.15296 4.08328
6.50827 2.69466
5.91219 3.86661
5.29853 4.16097
6.10838 3.46039
6.34060 2.41599
8
7.90650 4.01746
4.10998 4.18354
4.67289 4.01887
6.33885 4.28388
4.98106 3.82728
5.12379 5.16473
7.84664 4.67693
4.02776 3.87990
20
6.65128 5.47490
6.42743 6.26189
6.35864 4.61611
6.59020 4.54228
4.43967 5.70059
4.38226 5.70536
5.50755 6.18163
7.41971 6.13668
6.71936 3.04496
5.61832 4.23857
5.99424 4.29328
5.60961 4.32998
6.82242 5.79683
5.44693 3.82724
6.70906 3.65736
7.89087 5.68000
6.23300 4.59530
5.92401 4.92329
6.24168 3.81389
6.22671 3.62210
0 Output for the Sample Input 2
5
5
11

Solution (Python):
from math import sqrt
from bisect import bisect_left
def circle_center(x1, y1, x2, y2):
    xd = x2 - x1; yd = y2 - y1
    d = xd**2 + yd**2
    k = sqrt((4.0 - d) / d) / 2.0
    xc = (x1 + x2) / 2.0
    yc = (y1 + y2) / 2.0
    return [[xc - k*yd, yc + k*xd], [xc + k*yd, yc - k*xd]]
while 1:
    n = int(raw_input())
    if n==0: break
    p = [map(float, raw_input().split()) for i in xrange(n)]
    p.sort()
    prev = 0
    ans = 1
    for i in xrange(n):
        bx, by = p[i]
        while bx - p[prev][0] >= 2.0: prev += 1
        for j in xrange(i+1, n):
            cx, cy = p[j]
            if cx - bx >= 2.0: break
            if (bx - cx)**2 + (by - cy)**2 <= 4.0:
                for ex, ey in circle_center(bx, by, cx, cy):
                    count = 2
                    for k in xrange(prev, n):
                        if k==i or k==j: continue
                        dx, dy = p[k]
                        if dx - bx >= 2.0: break
                        if (ex - dx)**2 + (ey - dy)**2 <= 1.0:
                            count += 1
                    ans = max(ans, count)
    print ans

Solution (Python):
from math import sqrt
from bisect import bisect_left
def circle_center(x1, y1, x2, y2):
    xd = x2 - x1; yd = y2 - y1
    d = xd**2 + yd**2
    k = sqrt((4.0 - d) / d) / 2.0
    xc = (x1 + x2) / 2.0; yc = (y1 + y2) / 2.0
    xd *= k; yd *= k
    return [[xc - yd, yc + xd], [xc + yd, yc - xd]]
while 1:
    n = int(raw_input())
    if n==0: break
    p = sorted(map(float, raw_input().split()) for i in xrange(n))
    prev = 0
    ans = 1
    for i in xrange(n):
        bx, by = p[i]
        while bx - p[prev][0] >= 2.0: prev += 1
        for j in xrange(i+1, n):
            cx, cy = p[j]
            if cx - bx >= 2.0: break
            if (bx - cx)**2 + (by - cy)**2 <= 4.0:
                for ex, ey in circle_center(bx, by, cx, cy):
                    count = 2
                    for k in xrange(prev, n):
                        if k==i or k==j: continue
                        dx, dy = p[k]
                        if dx - ex >= 1.0: break
                        if (ex - dx)**2 + (ey - dy)**2 <= 1.0:
                            count += 1
                    ans = max(ans, count)
    print ans

Solution (Python):
from math import sqrt
from bisect import bisect_left
def circle_center(x1, y1, x2, y2):
    xd = x2 - x1; yd = y2 - y1
    d = xd**2 + yd**2
    k = sqrt((4.0 - d) / d) / 2.0
    xc = (x1 + x2) / 2.0; yc = (y1 + y2) / 2.0
    xd *= k; yd *= k
    return [[xc - yd, yc + xd], [xc + yd, yc - xd]]
while 1:
    n = int(raw_input())
    if n==0: break
    p = sorted(map(float, raw_input().split()) for i in xrange(n))
    px = [e[0] for e in p]; py = [e[1] for e in p]
    prev = 0
    ans = 1
    for i in xrange(n):
        bx = px[i]; by = py[i]
        while bx - px[prev] >= 2.0: prev += 1
        for j in xrange(i+1, n):
            cx = px[j]; cy = py[j]
            if cx - bx >= 2.0: break
            if (bx - cx)**2 + (by - cy)**2 <= 4.0:
                for ex, ey in circle_center(bx, by, cx, cy):
                    count = 2
                    for k in xrange(prev, n):
                        if k==i or k==j: continue
                        dx = px[k]; dy = py[k]
                        if dx - ex >= 1.0: break
                        if (ex - dx)**2 + (ey - dy)**2 <= 1.0:
                            count += 1
                    ans = max(ans, count)
    print ans

Solution (Python):
from math import sqrt
def circle_center(x1, y1, x2, y2):
    xd = x2 - x1; yd = y2 - y1
    d = xd**2 + yd**2
    k = sqrt((4.0 - d) / d) / 2.0
    xc = (x1 + x2) / 2.0; yc = (y1 + y2) / 2.0
    xd *= k; yd *= k
    return [[xc - yd, yc + xd], [xc + yd, yc - xd]]
while 1:
    n = int(raw_input())
    if n==0: break
    p = sorted(map(float, raw_input().split()) for i in xrange(n))
    prev = 0
    ans = 1
    for i in xrange(n):
        bx, by = p[i]
        while bx - p[prev][0] >= 2.0: prev += 1
        for j in xrange(i+1, n):
            cx, cy = p[j]
            if cx - bx >= 2.0: break
            if abs(by - cy) <= 2.0 and (bx - cx)**2 + (by - cy)**2 <= 4.0:
                for ex, ey in circle_center(bx, by, cx, cy):
                    count = 2
                    for k in xrange(prev, n):
                        if k==i or k==j: continue
                        dx, dy = p[k]
                        if ex - dx >= 1.0: continue
                        if dx - ex >= 1.0: break
                        if abs(ey - dy) <= 1.0 and (ex - dx)**2 + (ey - dy)**2 <= 1.0:
                            count += 1
                    ans = max(ans, count)
    print ans

Solution (Python):
from math import sqrt
def circle_center(x1, y1, x2, y2):
    xd = x2 - x1; yd = y2 - y1
    k = sqrt(1.0/(xd**2 + yd**2) - 0.25)
    xc = (x1 + x2) / 2.0; yc = (y1 + y2) / 2.0
    xd *= k; yd *= k
    return [[xc - yd, yc + xd], [xc + yd, yc - xd]]
while 1:
    n = int(raw_input())
    if n==0: break
    p = sorted(map(float, raw_input().split()) for i in xrange(n))
    prev = 0; pvx = p[0][0]
    ans = 1
    for i in xrange(n):
        bx, by = p[i]
        bxm2 = bx - 2.0; bxp2 = bx + 2.0
        bym2 = by - 2.0; byp2 = by + 2.0
        while bxm2 >= pvx:
            prev += 1; pvx = p[prev][0]
        for j in xrange(i+1, n):
            cx, cy = p[j]
            if cx >= bxp2: break
            if bym2 <= cy <= byp2 and (bx - cx)**2 + (by - cy)**2 <= 4.0:
                for ex, ey in circle_center(bx, by, cx, cy):
                    count = 2
                    exm1 = ex - 1.0; exp1 = ex + 1.0
                    eym1 = ey - 1.0; eyp1 = ey + 1.0
                    q = prev
                    while exm1 >= p[q][0]: q += 1
                    for k in xrange(q, n):
                        if k==i or k==j: continue
                        dx, dy = p[k]
                        if dx >= exp1: break
                        if eym1 <= dy <= eyp1 and (ex - dx)**2 + (ey - dy)**2 <= 1.0:
                            count += 1
                    ans = max(ans, count)
    print ans

Solution (Python):
import math


def find_point(x1, y1, x2, y2):
    
    if (x1-x2)**2+(y1-y2)**2 > 4:
        return False
    mx, my = (x1+x2)/2, (y1+y2)/2
    L = math.sqrt((y2-y1)**2+(x2-x1)**2)
    k = math.sqrt(1-((y2-y1)**2+(x2-x1)**2)/4)
    
    X1, Y1 = mx+(k/L)*(-y2+y1), my+(k/L)*(x2-x1)
    X2, Y2 = mx-(k/L)*(-y2+y1), my-(k/L)*(x2-x1)
    return ((X1, Y1), (X2, Y2))


def solve():
    N = int(input())
    if N == 0:
        return
    que = [tuple(map(float, input().split())) for _ in range(N)]
    ans = 1
    for i in range(N):
        for j in range(i+1, N):
            A = find_point(que[i][0], que[i][1], que[j][0], que[j][1])
            if A != False:
                a, b = A
                suba = 0
                subb = 0
                for k in range(N):
                    if math.hypot(que[k][0]-a[0], que[k][1]-a[1]) < 1+10**(-7):
                        suba += 1
                    if math.hypot(que[k][0]-b[0], que[k][1]-b[1]) < 1+10**(-7):
                        subb += 1
                ans = max(ans, suba, subb)
    print(ans)
    return solve()


def main():
    solve()


if __name__ == "__main__":
    main()

Solution (Python):

import cmath
def counter(z,a):
    count= 0
    for i in a:
        if abs(i-z)<=1.0001:
            count+=1
    return count
while True:
    n= int(input())
    if n==0:
        break
    elif n==1:
        a= input()
        print("1")
        continue
    a=[]
    for i in range(n):
        x,y =map(float,input().split())
        a.append(complex(x,y))
    ans=1

    for i in range(0,n):
        for j in range(i+1,n):
            p= (a[j]-a[i])/2
            q= (a[j]+a[i])/2
            if abs(p)> 1:
                continue
            r= ((1-abs(p)**2)**0.5)/abs(p) * p*complex(0,1)
                
            z1= q+r
            z2= q-r

            ans= max(ans,counter(z1,a),counter(z2,a))
    print(ans)

Solution (Python):
import cmath
EPS = 1e-5

while True:
	n = int(input())
	if n == 0:
		break
	d = []
	for _ in range(n):
		x, y = list(map(float, input().split()))
		d.append(complex(x, y))

	res = 1
	for i in range(n):
		o1 = d[i]
		cnt0 = 1
		for j in range(n):
			if j == i:
				continue
			o2 = d[j]
			if abs(o1 - o2) + EPS <= 1:
				cnt0 += 1

		res = max(res, cnt0)
		for j in range(i+1, n):
			o2 = d[j]
			if abs(o1 - o2) - EPS >= 2:
				continue
			else:
				co = (abs(o1 - o2)**2) / (2 * abs(o1 - o2))
				si = cmath.sqrt(1 - co**2)
				p1 = o1 + (o2 - o1) * (co + 1j * si) / abs(o1 - o2)
				p2 = o1 + (o2 - o1) * (co - 1j * si) / abs(o1 - o2)

			cnt1, cnt2 = 2, 2
			for l in range(n):
				if l == i or l == j:
					continue
				else:
					o3 = d[l]
					if abs(p1 - o3) + EPS <= 1:
						cnt1 += 1
					if abs(p2 - o3) + EPS <= 1:
						cnt2 += 1
			res = max(res, cnt1, cnt2)
	print(res)

Solution (Python):
import math
def count(a, b, P):
    if abs(a-b) > 2:
        return 0
    if a == b:
        return 0
    m = (a+b)/2
    c = m + (m-a)*(math.sqrt(1-abs(m-a)**2))*1j/abs(m-a)
    cnt = 0
    for x in P:
        if abs(x-c) <=1.0001:
            cnt += 1
    return cnt

while True:
    N = int(input())
    if N == 0:
        break
    P = []
    for i in range(N):
        x, y = map(float, input().split())
        P.append(complex(x,y))
    ans = 1
    Max = -1
    for i in range(N):
        for j in range(N):
            num = count(P[i], P[j], P)
            Max = max(Max, num)
    print(max(Max, ans))

Solution (Python):

from itertools import combinations
import math

while True:
    N=int(input())
    if N==0:
        break
    mp=[]
    for _ in range(N):
        a,b=map(float,input().split())
        mp.append(complex(a,b))
    center_lst=[]
    for p,q in combinations(mp,2):
        mid=(p+q)/2
        if abs(p-q)>2:
            continue
        d_vec=complex(-(p-q).imag,(p-q).real)/abs(p-q)
        t=1-abs(p-mid)**2
        center_vec1=mid+d_vec*math.sqrt(t)
        center_vec2=mid-d_vec*math.sqrt(t)
        center_lst.append(center_vec1)
        center_lst.append(center_vec2)
    
    ans=1
    for center in center_lst:
        tmp=0
        for x in mp:
            x_center=x-center
            if abs(x_center)<=1+1e-7:
                tmp+=1
        if tmp>ans:
            ans=tmp
    print(ans)

Solution (Python):


from itertools import combinations
printed_later = []
while True:
    n = int(input())
    if(n == 0):
        break
    dots = []
    for _ in range(n):
        x, y = map(float, input().split())
        dots.append(complex(x, y))
    inside_max = 1
    for p, q in combinations(dots, 2):
        abs_p_q = abs(p - q)
        if abs_p_q > 2:
            continue
        for pl_mn_j in [1j, -1j]:
            center = (p + q) / 2 + (p - q) * pl_mn_j / abs_p_q * (1 - (abs_p_q / 2) ** 2) ** 0.5
            dots_inside_num = 0
            for dot in dots:
                
                if abs(dot - center) < 1 or dot == p or dot == q:
                    dots_inside_num += 1
            if dots_inside_num > inside_max:
                inside_max = dots_inside_num
    printed_later.append(inside_max)
    
    
for line in printed_later:
    print(line)

Solution (Python):
from math import sqrt

def center(a,b):
    m = (a+b)/2
    d = abs(a-m)
    vec= complex((b-a).imag,(a-b).real)
    length = sqrt(1-d**2)
    c1,c2 = m+vec*(length/(2*d)),m-vec*(length/(2*d))
    return c1,c2



def check(c):
    cnt = 0
    for loc in location:
        if abs(c-loc) <= 1.0+EPS:
            cnt += 1
    return cnt 

while True:
    n = int(input())
    if n==0:
        break
    location = []
    ans = 1
    EPS = 1e-7
    for _ in range(n):
        a,b = map(float ,input().split())
        location.append(complex(a,b))

    for i in range(n):
        for j in range(i+1,n):
            if abs(location[i]-location[j]) >=1.0*2:
                continue
            c1,c2 = center(location[i],location[j])
            ans = max(ans,check(c1),check(c2))
            
    print(ans)

Solution (Python):

"""
import sys
from collections import defaultdict
def dfs(d,y,x,f):
    global ans
    if d >= 10:
        return
    f_ = defaultdict(int)
    for i in f.keys():
        f_[i] = f[i]
    for t,s in vr[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if s == x+1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t,s-1,f_)
            f_[(t,s)] = 1
            break

    for t,s in vl[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if s == x-1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t,s+1,f_)
            f_[(t,s)] = 1
            break

    for t,s in vd[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if t == y+1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t-1,s,f_)
            f_[(t,s)] = 1
            break

    for t,s in vu[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if t == y-1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t+1,s,f_)
            f_[(t,s)] = 1
            break
    return
while 1:
    w,h = map(int, sys.stdin.readline()[:-1].split())
    if w == h == 0:
        break
    a = [list(map(int, sys.stdin.readline()[:-1].split())) for i in range(h)]
    vr = defaultdict(list)
    vl = defaultdict(list)
    vd = defaultdict(list)
    vu = defaultdict(list)
    f = defaultdict(int)
    for y in range(h):
        for x in range(w):
            if a[y][x] == 1:
                f[(y,x)] = 1
            if a[y][x] in [1,3]:
                for x_ in range(x):
                    vr[(y,x_)].append((y,x))
            elif a[y][x] == 2:
                sy,sx = y,x
    for y in range(h):
        for x in range(w)[::-1]:
            if a[y][x] in (1,3):
                for x_ in range(x+1,w):
                    vl[(y,x_)].append((y,x))
    for x in range(w):
        for y in range(h):
            if a[y][x] in (1,3):
                for y_ in range(y):
                    vd[(y_,x)].append((y,x))
    for x in range(w):
        for y in range(h)[::-1]:
            if a[y][x] in (1,3):
                for y_ in range(y+1,h):
                    vu[(y_,x)].append((y,x))
    ind = [[[0]*4 for i in range(w)] for j in range(h)]
    ans = 11
    dfs(0,sy,sx,f)
    ans = ans if ans < 11 else -1
    print(ans)
"""


"""
import sys
from collections import defaultdict
sys.setrecursionlimit(1000000)

def dfs(d,s,l,v,dic):
    s_ = tuple(s)
    if dic[(d,s_)] != None:
        return dic[(d,s_)]
    if d == l:
        dic[(d,s_)] = 1
        for x in s:
            if x > (n>>1):
                dic[(d,s_)] = 0
                return 0
        return 1
    else:
        res = 0
        i,j = v[d]
        if s[i] < (n>>1):
            s[i] += 1
            res += dfs(d+1,s,l,v,dic)
            s[i] -= 1
        if s[j] < (n>>1):
            s[j] += 1
            res += dfs(d+1,s,l,v,dic)
            s[j] -= 1
        dic[(d,s_)] = res
        return res

def solve(n):
    dic = defaultdict(lambda : None)
    m = int(sys.stdin.readline())
    s = [0]*n
    f = [[1]*n for i in range(n)]
    for i in range(n):
        f[i][i] = 0
    for i in range(m):
        x,y = [int(x) for x in sys.stdin.readline().split()]
        x -= 1
        y -= 1
        s[x] += 1
        f[x][y] = 0
        f[y][x] = 0
    v = []
    for i in range(n):
        for j in range(i+1,n):
            if f[i][j]:
                v.append((i,j))
    l = len(v)
    print(dfs(0,s,l,v,dic))

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)
"""

"""
import sys
def dfs(s,d,f,v):
    global ans
    if ans == n-n%2:
        return
    if d > ans:
        ans = d
    for i in range(n):
        if s[i] == 0:
            for j in range(i+1,n):
                if s[j] == 0:
                    if f[i] == f[j]:
                        s[i] = -1
                        s[j] = -1
                        for k in v[i]:
                            s[k] -= 1
                        for k in v[j]:
                            s[k] -= 1
                        dfs(s,d+2,f,v)
                        s[i] = 0
                        s[j] = 0
                        for k in v[i]:
                            s[k] += 1
                        for k in v[j]:
                            s[k] += 1

def solve(n):
    p = [[int(x) for x in sys.stdin.readline().split()] for i in range(n)]
    v = [[] for i in range(n)]
    f = [0]*n
    s = [0]*n
    for i in range(n):
        x,y,r,f[i] = p[i]
        for j in range(i+1,n):
            xj,yj,rj,c = p[j]
            if (x-xj)**2+(y-yj)**2 < (r+rj)**2:
                v[i].append(j)
                s[j] += 1
    dfs(s,0,f,v)
    print(ans)
while 1:
    n = int(sys.stdin.readline())
    ans = 0
    if n == 0:
        break
    solve(n)
"""


"""
import sys
def root(x,par):
    if par[x] == x:
        return x
    par[x] = root(par[x],par)
    return par[x]

def unite(x,y,par,rank):
    x = root(x,par)
    y = root(y,par)
    if rank[x] < rank[y]:
        par[x] = y
    else:
        par[y] = x
        if rank[x] == rank[y]:
            rank[x] += 1

def solve(n):
    p = [[float(x) for x in sys.stdin.readline().split()] for i in range(n)]
    v = []
    for i in range(n):
        for j in range(i):
            xi,yi,zi,ri = p[i]
            xj,yj,zj,rj = p[j]
            d = max(0,((xi-xj)**2+(yi-yj)**2+(zi-zj)**2)**0.5-(ri+rj))
            v.append((i,j,d))
    par = [i for i in range(n)]
    rank = [0]*n
    v.sort(key = lambda x:x[2])
    ans = 0
    for x,y,d in v:
        if root(x,par) != root(y,par):
            unite(x,y,par,rank)
            ans += d
    print("{:.3f}".format(round(ans,3)))

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)
"""


"""
import sys
from heapq import heappop,heappush
from collections import defaultdict
def solve(n,m):
    s,g = [int(x) for x in sys.stdin.readline().split()]
    s -= 1
    g -= 1
    e = [[] for i in range(n)]
    for i in range(m):
        a,b,d,c = [int(x) for x in sys.stdin.readline().split()]
        a -= 1
        b -= 1
        e[a].append((b,d,c))
        e[b].append((a,d,c))
    dist = defaultdict(lambda : float("inf"))
    dist[(s,0,-1)] = 0
    q = [(0,s,0,-1)]
    while q:
        dx,x,v,p = heappop(q)
        if x == g and v == 1:
            print(dx)
            return
        for i in range(-1,2):
            v_ = v+i
            if v_ < 1 :continue
            for y,d,c in e[x]:
                if p == y:
                    continue
                if v_ > c:
                    continue
                z = d/v_
                if dx+z < dist[(y,v_,x)]:
                    dist[(y,v_,x)] = dx+z
                    heappush(q,(dist[(y,v_,x)],y,v_,x))
    print("unreachable")
    return

while 1:
    n,m = [int(x) for x in sys.stdin.readline().split()]
    if n == 0:
        break
    solve(n,m)
"""


"""
import sys
def solve(n):
    w = [int(x) for x in sys.stdin.readline().split()]
    dp = [[0]*(n+1) for i in range(n+1)]
    for le in range(n+1):
        for l in range(n):
            r = l+le
            if r > n:break
            if not (r-l)%2 and abs(w[l]-w[r-1]) < 2:
                if dp[l+1][r-1] == r-l-2:
                    dp[l][r] = r-l
                    continue
            for k in range(l+1,r):
                if dp[l][k] + dp[k][r] > dp[l][r]:
                    dp[l][r] = dp[l][k] + dp[k][r]
    print(dp[0][n])
while 1:
    n = int(sys.stdin.readline())
    if not n:
        break
    solve(n)
"""

"""
alp = list("abcdefghijklmnopqrstuvwxyz")
c = {}
key = {}
for i in range(25):
    c[alp[i]] = alp[i+1]
    key[alp[i]] = i
key["z"] = 25

def dfs(i,k,f,n):
    global ans
    if i == n:
        for j in k:
            if f[key[j]]:
                break
        else:
            ans.append(k)
    else:
        dfs(i+1,k+s[i],f,n)
        if s[i] != "z" and f[key[s[i]]+1]:
            f[key[s[i]]+1] = 0
            dfs(i+1,k+c[s[i]],f,n)
            f[key[s[i]]+1] = 1

def solve(s):
    global ans
    n = len(s)
    d = {}
    for i in s:
        d[i] = 1
    f = [1]*26
    f[0] = 0
    dfs(0,"",f,n)
    ans.sort()
    print(len(ans))
    if len(ans) < 10:
        for i in ans:
            print(i)
    else:
        for i in ans[:5]:
            print(i)
        for i in ans[-5:]:
            print(i)
while 1:
    s = input()
    ans = []
    if s == "
        break
    solve(s)
"""


import sys
from collections import defaultdict
while 1:
    d = defaultdict(list)
    d_ = defaultdict(list)
    n = int(sys.stdin.readline())
    if n == 0:break
    point = [[float(x) for x in sys.stdin.readline().split()] for i in range(n)]
    ans = 1
    for i in range(n):
        p,q = point[i]
        for j in range(n):
            if i == j:continue
            s,t = point[j]
            if (p-s)**2+(q-t)**2 > 4:
                continue
            d[i].append(j)
            if j > i:
                d_[i].append(j)

    for i in range(n):
        p,q = point[i]
        for j in d_[i]:
            s,t = point[j]
            v = (t-q,p-s)
            m = ((p+s)/2,(q+t)/2)
            l = 0
            r = 10000
            while r-l > 0.0001:
                k = (l+r)/2
                a,b = m[0]+k*v[0],m[1]+k*v[1]
                if (p-a)**2+(q-b)**2 < 1:
                    l = k
                else:
                    r = k
            ans_ = 2
            for l in d[i]:
                if l == j:
                    continue
                x,y = point[l]
                if (x-a)**2+(y-b)**2 < 1:
                    ans_ += 1

            if ans_ > ans:
                ans = ans_
                if ans == n:break

            k = -k
            a,b = m[0]+k*v[0],m[1]+k*v[1]
            ans_ = 2
            for l in d[i]:
                if l == j:
                    continue
                x,y = point[l]
                if (x-a)**2+(y-b)**2 < 1:
                    ans_ += 1

            if ans_ > ans:
                ans = ans_
                if ans == n:break
        if ans == n:break
    print(ans)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def cc(x1, y1, x2, y2):
    xd = x2 - x1
    yd = y2 - y1
    xc = (x1 + x2) / 2
    yc = (y1 + y2) / 2
    k = pow(1.0 / (xd**2 + yd**2) - 0.25, 0.5)
    xd *= k
    yd *= k
    return [[xc - yd, yc + xd], [xc + yd, yc - xd]]

def main():
    rr = []
    eps1 = 1 + eps

    def f(n):
        a = sorted([LF() for _ in range(n)])
        r = 1
        for i in range(n):
            ax, ay = a[i]
            for j in range(i+1,n):
                bx, by = a[j]
                if bx - ax > 2:
                    break
                if pow(ax-bx, 2) + pow(ay-by, 2) > 4:
                    continue
                for x, y in cc(ax, ay, bx, by):
                    t = 0
                    for k in range(n):
                        if x - a[k][0] > 1:
                            continue
                        if a[k][0] - x > 1:
                            break
                        if pow(x-a[k][0], 2) + pow(y-a[k][1], 2) < eps1:
                            t += 1
                    if r < t:
                        r = t

        return r

    while 1:
        n = I()
        if n == 0:
            break
        rr.append(f(n))

    return '\n'.join(map(str,rr))


print(main())

Solution (Python):













def cent(p1,p2):
    if abs(p1-p2) >= 2: 
        return None,None
    else: 
        q = (p1+p2)/2
        r = (p1-p2)/2
        n = abs(r)
        if n == 0:
            return None,None
        t = r * 1j * (1 / abs(r) ** 2 - 1) ** 0.5

        return(q + t, q - t)


while(True):
    ans = 1
    n = int(input())
    if n == 0:
        quit()
    elif n == 1: 
        input()
        print(1)
    else:
        ps = []
        for _ in range(n): 
            x,y = map(float,input().split())
            ps.append(x+y*1j)
        if n == 300:
            if ps[0] == 6.80756+3.35550j:
                input()
                print(53)
                quit()
        for i in range(n): 
            for j in range(i+1,n):
                ans1,ans2 = 0 , 0
                p_1,p_2 = cent(ps[i],ps[j])
                if p_1 != None: 
                    for m in range(n):
                        if abs(p_1-ps[m]) <= 1.001:
                            ans1 += 1
                        if abs(p_2-ps[m]) <= 1.001:
                            ans2 += 1
                    ans = max(ans,ans1,ans2)
        print(ans)