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();
    double[] x = new double[n];
    double[] y = new double[n];
    double minx = 1000;
    double maxx = 0;
    double miny = 1000;
    double maxy = 0;
    for(int i = 0; i < n; i++) {
      x[i] = sc.nextDouble();
      y[i] = sc.nextDouble();
      minx = Math.min(minx, x[i]);
      maxx = Math.max(maxx, x[i]);
      miny = Math.min(miny, y[i]);
      maxy = Math.max(maxy, y[i]);
    }
    double ansx = minx;
    double ansy = miny;
    
    double leftx = minx;
    double rightx = maxx;

    for(int i = 0; i < 50; i++) {
      double lx = (double)(2 * leftx + rightx) / (double)3;
      double rx = (double)(leftx + 2 * rightx) / (double)3;
      double flx = 0;
      double frx = 0;
      double lxy = 0;
      double rxy = 0;
      double lefty = miny;
      double righty = maxy;
      for(int j = 0; j < 50; j++) {
        double ly = (double)(2 * lefty + righty) / (double)3;
        double ry = (double)(lefty + 2 * righty) / (double)3;
        double t1 = 0;
        double t2 = 0;
        for(int k = 0; k < n; k++) {
          t1 = Math.max(t1, (lx - x[k]) * (lx - x[k]) + (ly - y[k]) * (ly - y[k]));
          t2 = Math.max(t2, (lx - x[k]) * (lx - x[k]) + (ry - y[k]) * (ry - y[k]));
        }
        if(t1 <= t2) {
          righty = ry;
          flx = t2;
          lxy = ry;
        } else {
          lefty = ly;
          flx = t1;
          lxy = ly;
        }
      }
      lefty = miny;
      righty = maxy;
      for(int j = 0; j < 50; j++) {
        double ly = (double)(2 * lefty + righty) / (double)3;
        double ry = (double)(lefty + 2 * righty) / (double)3;
        double t1 = 0;
        double t2 = 0;
        for(int k = 0; k < n; k++) {
          t1 = Math.max(t1, (rx - x[k]) * (rx - x[k]) + (ly - y[k]) * (ly - y[k]));
          t2 = Math.max(t2, (rx - x[k]) * (rx - x[k]) + (ry - y[k]) * (ry - y[k]));
        }
        if(t1 <= t2) {
          righty = ry;
          frx = t2;
          rxy = ry;
        } else {
          lefty = ly;
          frx = t1;
          rxy = ly;
        }                
      }      
      if(flx <= frx) {
        rightx = rx;
        ansx = rx;
        ansy = rxy;
      } else {
        leftx = lx;
        ansx = lx;
        ansy = lxy;
      }
    }

    double ans = 0;
    
    for(int i = 0; i < n; i++) {
      double t = (ansx - x[i]) * (ansx - x[i]) + (ansy - y[i]) * (ansy - y[i]);
      t = Math.sqrt(t);
      ans = Math.max(ans, t);
    }

    System.out.println(ans);
  }
}