Problem: Given are N points (x_i, y_i) in a two-dimensional plane.

Find the minimum radius of a circle such that all the points are inside or on it.

Constraints

* 2 \leq N \leq 50
* 0 \leq x_i \leq 1000
* 0 \leq y_i \leq 1000
* The given N points are all different.
* The values in input are all integers.

Input

Input is given from Standard Input in the following format:


N
x_1 y_1
:
x_N y_N


Output

Print the minimum radius of a circle such that all the N points are inside or on it.

Your output will be considered correct if the absolute or relative error from our answer is at most 10^{-6}.

Examples

Input

2
0 0
1 0


Output

0.500000000000000000


Input

3
0 0
0 1
1 0


Output

0.707106781186497524


Input

10
10 9
5 9
2 0
0 0
2 7
3 3
2 5
10 0
3 7
1 9


Output

6.726812023536805158

Solution (in JAVA):

Solution:
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        Point[] points = new Point[N];

        for (int i = 0; i < N; i++){
            points[i] = new Point(sc.nextInt(),sc.nextInt());
        }
        double left = 0.d;
        double right = (double)(Math.sqrt(1000*1000 + 1000*1000) / 2);

        while (right - left > 1e-9) {
            double mid = (right + left) / 2;
            List<Point> intersects = new ArrayList<>();
            for (int i = 0; i < N-1; i++){
                for (int j = i+1; j < N; j++){
                    intersects.addAll(intersects(points[i],mid,points[j],mid));
                }
            }
            if (suffice(N,points, mid,intersects)){
                right = mid;
            } else {
                left = mid;
            }
        }
        System.out.println(right);
    }

    private static boolean suffice(int N, Point[] points, double mid, List<Point> intersects) {
        for (Point p : intersects) {
            int count = 0;
            for (int i = 0; i < N; i++){
                if (p.dist(points[i]) < mid + 1e-9){
                    count++;
                }
            }
            if (count == N) {
                return true;
            }
        }
        return false;
    }
    private static List<Point> intersects(Point c1, double r1, Point c2, double r2){
        List<Point> list = new ArrayList<>();
        double dist = c1.dist(c2);

        double cm = (r1 * r1 - r2 * r2 + dist * dist) / dist / 2;
        Point m = c2.subtract(c1).scale(cm / dist).add(c1);
        double pm = Math.sqrt(r1 * r1 - cm * cm);
        Point mc = c1.subtract(m).scale(pm / cm);
        list.add(mc.rotate(Math.PI / 2).add(m));
        list.add(mc.rotate(-Math.PI / 2).add(m));
        return list;
    }

    public static class Point {
        public final double x;
        public final double y;

        public Point(double x, double y){
            this.x = x;
            this.y = y;
        }

        public Point scale(double s){
            return new Point(x * s, y * s);
        }

        public Point subtract(Point another){
            return new Point(x - another.x, y - another.y);
        }

        public Point add(Point another){
            return new Point(x + another.x, y + another.y);
        }

        public double dist(){
            return Math.sqrt(x * x + y * y);
        }

        public double distSq(Point another){
            return (another.x - x) * (another.x - x) + (another.y - y) * (another.y - y);
        }

        public double dist(Point another){
            return Math.sqrt(distSq(another));
        }

        public Point rotate(double theta){
            double newX = x * Math.cos(theta) - y * Math.sin(theta);
            double newY = x * Math.sin(theta) + y * Math.cos(theta);
            return new Point(newX, newY);
        }

        @Override
        public String toString() {
            return "(" + x + ", " + y + ")";
        }
    }
}