Language: C++


import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Scanner;


public class Main {
	
	
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		
		
		while(true){
			final int n = sc.nextInt();
			
			if(n == 0){
				break;
			}
			
			Point2D[] points = new Point2D[n];
			
			for(int i = 0; i < n; i++){
				points[i] = new Point2D(sc.nextDouble(), sc.nextDouble());
			}
			
			int max = 0;
			
			for(int fst = 0; fst < n; fst++){
				for(int snd = 0; snd < n; snd++){
					Point2D[] cross = Point2D.cross_ss(points[fst], 1, points[snd], 1);
					
					for(Point2D cross_c : cross){
						int count = 0;
						
						for(int i = 0; i < n; i++){
							if(cross_c.dist(points[i]) <= 1.0 + Point2D.EPS){
								count++;
							}
								
						}
						
						max = Math.max(max, count);
					}
				}
			}
			
			System.out.println(max);
		}
		
	}
}

class Point2D {
    public double x;
    public double y;
 
    public static final double EPS = 1e-4;
 
    public Point2D(double x, double y) {
        this.x = x;
        this.y = y;
    }
 
    public Point2D(Point2D point) {
        this.x = point.x;
        this.y = point.y;
    }
 
    public String toString() {
        return x + "," + y;
    }
 
    @Override
    public boolean equals(Object o) {
        if (o instanceof Point2D) {
            Point2D another = (Point2D) o;
            if (this.x - EPS < another.x && this.x + EPS > another.x
                    && this.y - EPS < another.y && this.y + EPS > another.y) {
                return true;
            }
             
            return false;
 
            // return this.x == another.x && this.y == another.y;
        }
        return false;
    }
 
    public Point2D add(double x, double y) {
        return new Point2D(this.x + x, this.y + y);
    }
 
    public Point2D sub(double x, double y) {
        return add(-x, -y);
    }
 
    public Point2D add(Point2D another) {
        return add(another.x, another.y);
    }
 
    public Point2D sub(Point2D another) {
        return sub(another.x, another.y);
    }
 
    public Point2D mul(double d) {
        return new Point2D(this.x * d, this.y * d);
    }
 
    public Point2D div(double d) {
        return new Point2D(this.x / d, this.y / d);
    }
 
    public double dot(double x, double y) {
        return this.x * x + this.y * y;
    }
 
    public double dot(Point2D another) {
        return dot(another.x, another.y);
    }
 
    public double cross(double x, double y) {
        return this.x * y - this.y * x;
    }
 
    public double cross(Point2D another) {
        return cross(another.x, another.y);
    }
 
    public double dist(double x, double y) {
        return Math.sqrt((this.x - x) * (this.x - x) + (this.y - y)
                * (this.y - y));
    }
 
    public double dist(Point2D another) {
        return dist(another.x, another.y);
    }
 
    public double dist_o() {
        return dist(0, 0);
    }
 
    public Point2D unit() {
        return div(dist_o());
    }
 
    public boolean pol(Point2D start, Point2D end) {
        return end.sub(start).cross(this.sub(start)) < EPS;
    }
 
    public boolean pos(Point2D start, Point2D end) {
        return (start.dist(this) + this.dist(end) < start.dist(end) + EPS);
    }
 
    public double pld(Point2D start, Point2D end) {
        return Math.abs((end.sub(start).cross(this.sub(start)))
                / end.sub(start).dist_o());
    }
 
    public double psd(Point2D start, Point2D end) {
        if (end.sub(start).dot(this.sub(start)) < EPS) {
            return this.dist(start);
        } else if (start.sub(end).dot(this.sub(end)) < EPS) {
            return this.dist(end);
        } else {
            return end.sub(start).cross(this.sub(start)) / end.dist(start);
        }
    }
 
    public static boolean intersect_s(Point2D a1, Point2D a2, Point2D b1,
            Point2D b2) {
        return (a2.sub(a1).cross(b1.sub(a1)) * a2.sub(a1).cross(b2.sub(a1)) < EPS)
                && (b2.sub(b1).cross(a1.sub(b1)) * b2.sub(b1).cross(a2.sub(b1)) < EPS);
    }
 
    public static boolean insersect_l(Point2D a1, Point2D a2, Point2D b1,
            Point2D b2) {
        return a1.sub(a2).cross(b1.sub(b2)) < EPS;
    }
 
    public static Point2D interpoint_s(Point2D a1, Point2D a2, Point2D b1,
            Point2D b2) {
        Point2D b = b2.sub(b1);
        double d1 = Math.abs(b.cross(a1.sub(b1)));
        double d2 = Math.abs(b.cross(a2.sub(b1)));
        double t = d1 / (d1 + d2);
        Point2D a = a2.sub(a1), v = a.mul(t);
        return a1.add(v);
    }
 
    public static Point2D interpoint_l(Point2D a1, Point2D a2, Point2D b1,
            Point2D b2) {
        Point2D a = a2.sub(a1);
        Point2D b = b2.sub(b1);
        double t = b.cross(b1.sub(a1)) / b.cross(a);
        Point2D v = a.mul(t);
        return a1.add(v);
    }
 
    public static Point2D[] cross_ss(Point2D p1, double r1, Point2D p2,
            double r2) {
        double dis = p1.dist(p2);
 
        if (r1 + EPS > r2 && r1 - EPS < r2 && dis < EPS) {
            return new Point2D[0]; // same
        }
 
        if (dis - EPS < r1 + r2 && dis + EPS > r1 + r2) {
            Point2D tmp = p2.sub(p1);
            tmp = tmp.mul(r1 / tmp.dist_o());
            Point2D ret[] = new Point2D[1];
            ret[0] = p1.add(tmp);
            return ret;
        } else if (dis + EPS > r1 + r2) {
            return new Point2D[0]; // out
        }
 
        double dis_m = Math.abs(r1 - r2);
 
        if (dis_m + EPS > dis && dis_m - EPS < dis) {
            Point2D tmp = null;
            if (r1 > r2) {
                tmp = p2.sub(p1);
            } else {
                tmp = p1.sub(p2);
            }
 
            double min = Math.min(r1, r2);
 
            tmp = tmp.mul((min + tmp.dist_o()) / tmp.dist_o());
 
            Point2D ret[] = new Point2D[1];
            ret[0] = p1.add(tmp);
            return ret;
        } else if (dis_m + EPS > dis) {
            return new Point2D[0]; // inner
        } else {
            Point2D ret[] = new Point2D[2];
 
            double theta = Math.acos((dis * dis + r1 * r1 - r2 * r2)
                    / (2 * dis * r1));
            double a = Math.atan2(p2.y - p1.y, p2.x - p1.x);
 
            ret[0] = new Point2D(r1 * Math.cos(a + theta) + p1.x, r1
                    * Math.sin(a + theta) + p1.y);
            ret[1] = new Point2D(r1 * Math.cos(a - theta) + p1.x, r1
                    * Math.sin(a - theta) + p1.y);
            return ret;
        }
    }
 
    public void interpoint_lc(Point2D start, Point2D end, Point2D c, double r,
            Point2D ans[]) {
        if (c.pld(start, end) > r + EPS)
            return;
        Point2D v = end.sub(start).unit();
        double delta = v.dot(start.sub(c)) * v.dot(start.sub(c))
                - start.dist(c) * start.dist(c) + r * r;
        double t = -v.dot(start.sub(c));
        double s = Math.sqrt(delta);
        ans[0] = start.add(v.mul(t + s));
        ans[1] = start.add(v.mul(t + s));
    }
 
    public Point2D normal_vector(Point2D p, Point2D a, Point2D b) {
        Point2D v = b.sub(a).unit();
        v = v.cross(p.sub(a)) > 0 ? new Point2D(v.y, (-1) * v.x) : new Point2D(
                (-1) * v.y, v.x);
        return v.mul(p.pld(a, b));
    }
 
    public double area(Point2D a, Point2D b, Point2D c) {
        return Math.abs((c.sub(a).cross(b.sub(a))) * 0.5);
    }
 
}

Compiler output:
a.cc:76:5: error: stray '@' in program
   76 |     @Override
      |     ^
a.cc:2:1: error: 'import' does not name a type
    2 | import java.io.IOException;
      | ^~~~~~
a.cc:2:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:3:1: error: 'import' does not name a type
    3 | import java.util.HashMap;
      | ^~~~~~
a.cc:3:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:4:1: error: 'import' does not name a type
    4 | import java.util.LinkedList;
      | ^~~~~~
a.cc:4:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:5:1: error: 'import' does not name a type
    5 | import java.util.PriorityQueue;
      | ^~~~~~
a.cc:5:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:6:1: error: 'import' does not name a type
    6 | import java.util.Scanner;
      | ^~~~~~
a.cc:6:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:9:1: error: expected unqualified-id before 'public'
    9 | public class Main {
      | ^~~~~~
a.cc:57:11: error: expected ':' before 'double'
   57 |     public double x;
      |           ^~~~~~~
      |           :
a.cc:58:11: error: expected ':' before 'double'
   58 |     public double y;
      |           ^~~~~~~
      |           :
a.cc:60:11: error: expected ':' before 'static'
   60 |     public static final double EPS = 1e-4;
      |           ^~~~~~~
      |           :
a.cc:60:19: error: 'final' does not name a type
   60 |     public static final double EPS = 1e-4;
      |                   ^~~~~
a.cc:62:11: error: expected ':' before 'Point2D'
   62 |     public Point2D(double x, double y) {
      |           ^~~~~~~~
      |           :
a.cc:67:11: error: expected ':' before 'Point2D'
   67 |     public Point2D(Point2D point) {
      |           ^~~~~~~~
      |           :
a.cc:67:12: error: invalid constructor; you probably meant 'Point2D (const Point2D&)'
   67 |     public Point2D(Point2D point) {
      |            ^~~~~~~
a.cc:72:11: error: expected ':' before 'String'
   72 |     public String toString() {
      |           ^~~~~~~
      |           :
a.cc:72:12: error: 'String' does not name a type
   72 |     public String toString() {
      |            ^~~~~~
a.cc:76:6: error: 'Override' does not name a type
   76 |     @Override
      |      ^~~~~~~~
a.cc:92:11: error: expected ':' before 'Point2D'
   92 |     public Point2D add(double x, double y) {
      |           ^~~~~~~~
      |           :
a.cc:96:11: error: expected ':' before 'Point2D'
   96 |     public Point2D sub(double x, double y) {
      |           ^~~~~~~~
      |           :
a.cc:100:11: error: expected ':' before 'Point2D'
  100 |     public Point2D add(Point2D another) {
      |           ^~~~~~~~
      |           :
a.cc:104:11: error: expected ':' before 'Point2D'
  104 |     public Point2D sub(Point2D another) {
      |           ^~~~~~~~
      |           :
a.cc:108:11: error: expected ':' before 'Point2D'
  108 |     public Point2D mul(double d) {
      |           ^~~~~~~~
      |           :
a.cc:112:11: error: expected ':' before 'Point2D'
  112 |     public Point2D div(double d) {
      |           ^~~~~~~~
      |           :
a.cc:116:11: error: expected ':' before 'double'
  116 |     public double dot(double x, double y) {
      |           ^~~~~~~
      |           :
a.cc:120:11: error: expected ':' before 'double'
  120 |     public double dot(Point2D another) {
      |           ^~~~~~~
      |           :
a.cc:124:11: error: expected ':' before 'double'
  124 |     public double cross(double x, double y) {
      |           ^~~~~~~
      |           :
a.cc:128:11: error: expected ':' before 'double'
  128 |     public double cross(Point2D another) {
      |           ^~~~~~~
      |           :
a.cc:132:11: error: expected ':' before 'double'
  132 |     public double dist(double x, double y) {
      |           ^~~~~~~
      |           :
a.cc:137:11: error: expected ':' before 'double'
  137 |     public double dist(Point2D another) {
      |           ^~~~~~~
      |           :
a.cc:141:11: error: expected ':' before 'double'
  141 |     public double dist_o() {
      |           ^~~~~~~
      |           :
a.cc:145:11: error: expected ':' before 'Point2D'
  145 |     public Point2D unit() {
      |           ^~~~~~~~
      |           :
a.cc:149:11: error: expected ':' before 'boolean'
  149 |     public boolean pol(Point2D start, Point2D end) {
      |           ^~~~~~~~
      |           :
a.cc:149:12: error: 'boolean' does not name a type; did you mean 'bool'?
  149 |     public boolean pol(Point2D start, Point2D end) {
      |            ^~~~~~~
      |            bool
a.cc:153:11: error: expected ':' before 'boolean'
  153 |     public boolean pos(Point2D start, Point2D end) {
      |           ^~~~~~~~
      |           :
a.cc:153:12: error: 'boolean' does not name a type; did you mean 'bool'?
  153 |     public boolean pos(Point2D start, Point2D end) {
      |            ^~~~~~~
      |            bool
a.cc:157:11: error: expected ':' before 'double'
  157 |     public double pld(Point2D start, Point2D end) {
      |           ^~~~~~~
      |           :
a.cc:162:11: error: expected ':' before 'double'
  162 |     public double psd(Point2D start, Point2D end) {
      |           ^~~~~~~
      |           :
a.cc:172:11: error: expected ':' before 'static'
  172 |     public static boolean intersect_s(Point2D a1, Point2D a2, Point2D b1,
      |           ^~~~~~~
      |           :
a.cc:172:19: error: 'boolean' does not name a type; did you mean 'bool'?
  172 |     public static boolean intersect_s(Point2D a1, Point2D a2, Point2D b1,
      |                   ^~~~~~~
      |                   bool
a.cc:178:11: error: expected ':' before 'static'
  178 |     public static boolean insersect_l(Point2D a1, Point2D a2, Point2D b1,
      |           ^~~~~~~
      |           :
a.cc:178:19: error: 'boolean' does not name a type; did you mean 'bool'?
  178 |     public static boolean insersect_l(Point2D a1, Point2D a2, Point2D b1,
      |                   ^~~~~~~
      |                   bool
a.cc:183:11: error: expected ':' before 'static'
  183 |     public static Point2D interpoint_s(Point2D a1, Point2D a2, Point2D b1,
      |           ^~~~~~~
      |           :
a.cc:193:11: error: expected ':' before 'static'
  193 |     public static Point2D interpoint_l(Point2D a1, Point2D a2, Point2D b1,
      |           ^~~~~~~
      |           :
a.cc:202:11: error: expected ':' before 'static'
  202 |     public static Point2D[] cross_ss(Point2D p1, double r1, Point2D p2,
      |           ^~~~~~~
      |           :
a.cc:202:26: error: expected unqualified-id before '[' token
  202 |     public static Point2D[] cross_ss(Point2D p1, double r1, Point2D p2,
      |                          ^
a.cc:254:11: error: expected ':' before 'void'
  254 |     public void interpoint_lc(Point2D start, Point2D end, Point2D c, double r,
      |           ^~~~~
      |           :
a.cc:267:11: error: expected ':' before 'Point2D'
  267 |     public Point2D normal_vector(Point2D p, Point2D a, Point2D b) {
      |           ^~~~~~~~
      |           :
a.cc:274:11: error: expected ':' before 'double'
  274 |     public double area(Point2D a, Point2D b, Point2D c) {
      |           ^~~~~~~
      |           :
a.cc:278:2: error: expected ';' after class definition
  278 | }
      |  ^
      |  ;
a.cc: In constructor 'Point2D::Point2D(double, double)':
a.cc:63:14: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
   63 |         this.x = x;
      |              ^
a.cc:64:14: error: request for member 'y' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
   64 |         this.y = y;
      |              ^
a.cc: In member function 'Point2D Point2D::add(double, double)':
a.cc:93:33: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
   93 |         return new Point2D(this.x + x, this.y + y);
      |                                 ^
a.cc:93:45: error: request for member 'y' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
   93 |         return new Point2D(this.x + x, this.y + y);
      |                                             ^
a.cc: In member function 'Point2D Point2D::mul(double)':
a.cc:109:33: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  109 |         return new Point2D(this.x * d, this.y * d);
      |                                 ^
a.cc:109:45: error: request for member 'y' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  109 |         return new Point2D(this.x * d, this.y * d);
      |                                             ^
a.cc: In member function 'Point2D Point2D::div(double)':
a.cc:113:33: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  113 |         return new Point2D(this.x / d, this.y / d);
      |                                 ^
a.cc:113:45: error: request for member 'y' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  113 |         return new Point2D(this.x / d, this.y / d);
      |                                             ^
a.cc: In member function 'double Point2D::dot(double, double)':
a.cc:117:21: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  117 |         return this.x * x + this.y * y;
      |                     ^
a.cc:117:34: error: request for member 'y' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  117 |         return this.x * x + this.y * y;
      |                                  ^
a.cc: In member function 'double Point2D::cross(double, double)':
a.cc:125:21: error: request for member 'x' in '(Point2D*)this', which is of pointer type 'Point2D*' (maybe you meant to use '->' ?)
  125 |         return this.x * y - this.y * x;
      |                     ^
a.cc:125:34: erro