Problem: Luyi has n circles on the plane. The i-th circle is centered at (xi, yi). At the time zero circles start to grow simultaneously. In other words, the radius of each circle at time t (t > 0) is equal to t. The circles are drawn as black discs on an infinite white plane. So at each moment the plane consists of several black and white regions. Note that the circles may overlap while growing.

<image>

We define a hole as a closed, connected white region. For instance, the figure contains two holes shown by red border. During growing some holes may be created and it is easy to see that each created hole will disappear eventually. Luyi asks you to find moment of time such that the last hole disappears. In other words, you should find the first moment such that no hole can be seen after that.

Input

The first line of the input contains integer n (1 ≤ n ≤ 100). Each of the next n lines contains two integers xi and yi ( - 104 ≤ xi, yi ≤ 104), indicating the location of i-th circle.

It's guaranteed that no two circles are centered at the same point.

Output

Print the moment where the last hole disappears. If there exists no moment in which we can find holes print -1.

The answer will be considered correct if the absolute or relative error does not exceed 10 - 4.

Examples

Input

3
0 0
1 1
2 2


Output

-1


Input

4
0 0
0 2
2 2
2 0


Output

1.414214


Input

4
0 1
0 -1
-2 0
4 0


Output

2.125000

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
//         _______________________________________________ _________
//        |   Input Mode     |      Output Mode    | mode | comment |
//        |------------------|---------------------|----- |---------|
//        |   input.txt      |      System.out     |  0   |    mj   |
//        |   System.in      |      System.out     |  1   |  T / CF |
//        |<problemName>.in  |  <problemName>.out  |  2   |         |
//        |   input.txt      |      output.txt     |  3   |    C    |
//        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private class Three {
        double n0, n1, z;

        private Three(double n0, double n1, double z){
            this.n0 = n0;
            this.n1 = n1;
            this.z = z;
        }
    }
    private double dist(double x0, double y0, double x1, double y1){
        return sqrt((x1 - x0)*(x1 - x0) + (y1 - y0)*(y1 - y0));
    }
    private boolean isAngleAcute(double x0, double y0, double x1, double y1){
        return x0*x1 + y0*y1 > 0;
    }
    private double getAngle(double x0, double y0, double x1, double y1){
        double cosPhi = (x0*x1 + y0*y1) / dist(x0, y0, 0, 0) / dist(0, 0, x1, y1);
        double orient = x0*y1 - x1*y0;
        double ans = acos(cosPhi);
        if(orient < 0)
            ans = -ans;
        return ans;
    }
    private boolean isTriangleAcute(double x0, double y0, double x1, double y1, double x2, double y2){
        boolean acute0 = isAngleAcute(x0-x1, y0-y1, x0-x2, y0-y2);
        boolean acute1 = isAngleAcute(x1-x0, y1-y0, x1-x2, y1-y2);
        boolean acute2 = isAngleAcute(x2-x0, y2-y0, x2-x1, y2-y1);
        return acute0 && acute1 && acute2;
    }
    private Three lineIntersection(double a0, double b0, double c0, double a1, double b1, double c1){
        double det = a0*b1 - a1*b0;
        if(det == 0)
            return null;
        double x_int = (c0*b1 - c1*b0) / det;
        double y_int = (a0*c1 - a1*c0) / det;
        return new Three(x_int, y_int, -1);
    }
    private Three lineByPoints(double x0, double y0, double x1, double y1){
        double a = y0 - y1;
        double b = x1 - x0;
        double c = x1*y0 - x0*y1;
        return new Three(a, b, c);
    }

    private void solve() throws IOException {
        final double EPS = 1e-7;
        int n = io.nI(), x[] = new int[n], y[] = new int[n];
        for(int i = 0; i<n; i++){
            x[i] = io.nI();
            y[i] = io.nI();
        }
        double answer = -1.0;
        for(int i0 = 0; i0<n; i0++)
            for(int i1 = i0 + 1; i1<n; i1++)
                for(int i2 = i1 + 1; i2<n; i2++)
                    if(isTriangleAcute(x[i0], y[i0], x[i1], y[i1], x[i2], y[i2])){
                        Three line0 = lineByPoints(x[i0], y[i0], x[i1], y[i1]);
                        double x0_c = (x[i0] + x[i1]) / 2.0;
                        double y0_c = (y[i0] + y[i1]) / 2.0;

                        Three line1 = lineByPoints(x[i0], y[i0], x[i2], y[i2]);
                        double x1_c = (x[i0] + x[i2]) / 2.0;
                        double y1_c = (y[i0] + y[i2]) / 2.0;

                        double a0 =  line0.n1;
                        double b0 = -line0.n0;
                        double c0 = a0*x0_c + b0*y0_c;

                        double a1 =  line1.n1;
                        double b1 = -line1.n0;
                        double c1 = a1*x1_c + b1*y1_c;

                        Three insec = lineIntersection(a0, b0, c0, a1, b1, c1);
                        if(insec == null)
                            continue;
                        double x_int = insec.n0, y_int = insec.n1;
                        double rad = dist(x_int, y_int, x[i0], y[i0]);
                        boolean alreadyCovered = false;
                        for(int i3 = 0; i3<n; i3++)
                            if(dist(x_int, y_int, x[i3], y[i3]) + EPS < rad){
                                alreadyCovered = true;
                                break;
                            }
                        if(!alreadyCovered)
                            answer = max(answer, rad);
                    }else{
                        int j0 = -1, j1 = -1, j2 = -1;
                        double phi;

                        phi = getAngle(x[i0]-x[i1], y[i0]-y[i1], x[i0]-x[i2], y[i0]-y[i2]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//012
                            j0 = i1;
                            j1 = i0;
                            j2 = i2;
                        }
                        phi = getAngle(x[i0]-x[i2], y[i0]-y[i2], x[i0]-x[i1], y[i0]-y[i1]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//021
                            j0 = i2;
                            j1 = i0;
                            j2 = i1;
                        }
                        phi = getAngle(x[i1]-x[i2], y[i1]-y[i2], x[i1]-x[i0], y[i1]-y[i0]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//120
                            j0 = i2;
                            j1 = i1;
                            j2 = i0;
                        }
                        phi = getAngle(x[i1]-x[i0], y[i1]-y[i0], x[i1]-x[i2], y[i1]-y[i2]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//102
                            j0 = i0;
                            j1 = i1;
                            j2 = i2;
                        }
                        phi = getAngle(x[i2]-x[i0], y[i2]-y[i0], x[i2]-x[i1], y[i2]-y[i1]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//201
                            j0 = i0;
                            j1 = i2;
                            j2 = i1;
                        }
                        phi = getAngle(x[i2]-x[i1], y[i2]-y[i1], x[i2]-x[i0], y[i2]-y[i0]);
                        if(j0 == -1 && abs(PI/2 - phi) < EPS){//210
                            j0 = i1;
                            j1 = i2;
                            j2 = i0;
                        }
                        //phi = ...
                        if(j0 == -1)
                            continue;
                        Three line0 = lineByPoints(x[j1], y[j1], x[j0], y[j0]);
                        Three line1 = lineByPoints(x[j1], y[j1], x[j2], y[j2]);

                        double a0 = line0.n0;
                        double b0 = line0.n1;
                        double c0 = x[j2]*a0 + y[j2]*b0;

                        double a1 = line1.n0;
                        double b1 = line1.n1;
                        double c1 = x[j0]*a1 + y[j0]*b1;

                        Three insec = lineIntersection(a0, b0, c0, a1, b1, c1);
                        double x_prob = insec.n0, y_prob = insec.n1;
                        for(int i3 = 0; i3<n; i3++){
                            if(abs(x[i3] - x_prob) + abs(y[i3] - y_prob) < EPS){
                                double x_int = (x[j0] + x[j2]) / 2.0;
                                double y_int = (y[j0] + y[j2]) / 2.0;
                                double rad = dist(x_int, y_int, x[j1], y[j1]);
                                boolean clsExists = false;
                                for(int i4 = 0; i4<n; i4++)
                                    if(dist(x_int, y_int, x[i4], y[i4]) + EPS < rad){
                                        clsExists = true;
                                        break;
                                    }
                                if(!clsExists)
                                    answer = max(answer, rad);
                                break;
                            }
                        }
                    }
        io.wf("%.6f\n", answer);
    }//2.2250738585072012e-308

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
//         _______________________________________________ _________
//        |   Input Mode     |      Output Mode    | mode | comment |
//        |------------------|---------------------|----- |---------|
//        |   input.txt      |      System.out     |  0   |    mj   |
//        |   System.in      |      System.out     |  1   |  T / CF |
//        |<problemName>.in  |  <problemName>.out  |  2   |         |
//        |   input.txt      |      output.txt     |  3   |    C    |
//        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}