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.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.awt.geom.Point2D;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author emotionalBlind
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.readInt();
        Point2D.Double[] points = new Point2D.Double[n];
        for (int i = 0; i < n; ++i) {
            double x = in.readDouble();
            double y = in.readDouble();
            points[i] = new Point2D.Double(x, y);
        }
        double[][] dist = new double[n][n];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                dist[i][j] = points[i].distance(points[j]);
            }
        }
        double res = -1.0;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                for (int k = j + 1; k < n; ++k) {
                    Triangle t = new Triangle(points[i], points[j], points[k]);
                    if (t.isAcute()) {
                        Point2D o = t.getCircumcenter();
                        double r = o.distance(points[i]);
                        if (check(o, points, r)) {
                            res = Math.max(res, r);
                        }
                    }
                }
            }
        }
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                boolean found = false;
                for (int k = 0; k < n; ++k) {
                    if (found) break;
                    for (int l = k + 1; l < n; ++l) {
                        if (found) break;
                        if (Math.abs(dist[i][j] - dist[k][l]) > 1e-9) continue;
                        if (Math.abs(dist[i][k] - dist[j][l]) > 1e-9) continue;
                        if (Math.abs(dist[i][l] - dist[k][j]) > 1e-9) continue;
                        if (Math.abs(dist[i][j] - dist[i][l]) < 1e-9) continue;
                        if (Math.abs(dist[i][j] - dist[i][k]) < 1e-9) continue;
                        found = true;
                        double r = dist[i][j] / 2.0;
                        Point2D.Double o = new Point2D.Double((points[i].getX() + points[j].getX()) / 2.0,
                                (points[i].getY() + points[j].getY()) / 2.0);
                        if (check(o, points, r)) {
                            res = Math.max(res, r);
                        }
                    }
                }
            }
        }
        if (res < -0.5) {
            out.printLine(-1);
        } else {
            out.printLine(res);
        }
    }

    boolean check(Point2D p, Point2D[] points, double d) {
        for (int i = 0; i < points.length; ++i) {
            if (p.distance(points[i]) + 1e-9 < d) {
                return false;
            }
        }
        return true;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        // InputMismatchException -> UnknownError
        if (numChars == -1)
            throw new UnknownError();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new UnknownError();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        } else if (c == '+') {
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public double readDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        boolean hasFraction = false;
        do {
            if (c == '.') {
                hasFraction = true;
                break;
            }
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));

        if (hasFraction) {
            double mul = 0.1;
            while (true) {
                c = read();
                if (isSpaceChar(c)) break;
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res += mul * (c - '0');
                mul /= 10;
            }
        }
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(outputStream);
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

}

class Triangle {
    public Triangle(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public Triangle(double x1, double y1, double x2, double y2, double x3, double y3) {
        A = new Point2D.Double(x1, y1);
        B = new Point2D.Double(x2, y2);
        C = new Point2D.Double(x3, y3);
        this.a = B.distance(C);
        this.b = A.distance(C);
        this.c = B.distance(A);
    }

    public Triangle(Point2D.Double p1, Point2D.Double p2, Point2D.Double p3) {
        this(p1.getX(), p1.getY(), p2.getX(), p2.getY(), p3.getX(), p3.getY());
    }

    public boolean isAcute() {
        double a2 = a * a;
        double b2 = b * b;
        double c2 = c * c;
        if (a2 + 1e-9 < b2 + c2 && b2 + 1e-9 < a2 + c2 && c2 + 1e-9 < a2 + b2) {
            return true;
        } else {
            return false;
        }
    }

    public Point2D getCircumcenter() {
        SegmentDouble s1 = new SegmentDouble(A.getX(), A.getY(), B.getX(), B.getY());
        SegmentDouble s2 = new SegmentDouble(A.getX(), A.getY(), C.getX(), C.getY());
        Line l1 = s1.getPerpendicularBisector();
        Line l2 = s2.getPerpendicularBisector();
        return l1.getIntersectingPoint(l2);
    }

    Point2D A;
    Point2D B;
    Point2D C;

    public double a;
    public double b;
    public double c;
}

class SegmentDouble {
    private double x1;
    private double y1;
    private double x2;
    private double y2;

    public SegmentDouble(double x1, double y1, double x2, double y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }

    public Line getPerpendicularBisector() {
        double x = (x1 + x2) / 2.0;
        double y = (y1 + y2) / 2.0;
        Line line1 = new Line(x1, y1, x2, y2);
        return line1.getPerpendicularLine(x, y);
    }
}

class Line {
    double a;
    double b;
    double c;

    public Line(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public Line(double x1, double y1, double x2, double y2) {
        this.a = y1 - y2;
        this.b = x2 - x1;
        this.c = y1 * (x1 - x2) - x1 * (y1 - y2);
    }

    // get perpendicular line which contains (x1, y1)
    public Line getPerpendicularLine(double x1, double y1) {
        return new Line(b, -a, a * y1 - b * x1);
    }

    public Point2D.Double getIntersectingPoint(Line that) {
        double x = (this.b * that.c - that.b * this.c) / (this.a * that.b - that.a * this.b);
        double y = (that.a * this.c - this.a * that.c) / (this.a * that.b - that.a * this.b);
        Point2D.Double point = new Point2D.Double(x, y);
        return point;
    }
}