import java.io.*;
import java.util.*;
import java.math.*;

public class stadium_ab implements Runnable {
    public static void main(String[] args) {
	new Thread(new stadium_ab()).start();
    }

    @Override
    public void run() {
	try {
	    br = new BufferedReader(new FileReader("stadium.in"));
	    out = new PrintWriter("stadium.out");
	    solve();
	    out.close();
	} catch (Throwable e) {
	    e.printStackTrace();
	    System.exit(-1);
	}
    }

    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;
    boolean eof = true;

    String cnv(String a) {
	return a.equals("") ? "0" : a;
    }

    String nextToken() {
	while (st == null || !st.hasMoreElements()) {
	    try {
		st = new StringTokenizer(br.readLine());
	    } catch (Exception e) {
		eof = true;
		return "";
	    }
	}
	return st.nextToken();
    }

    int nextInt() {
	return Integer.parseInt(cnv(nextToken()));
    }

    double nextDouble() {
	return Double.parseDouble(cnv(nextToken()));
    }

    void myAssert(boolean e) {
	if (!e) {
	    throw new Error("assertion failed");
	}
    }
    
    final int MIN_N = 3;
    final int MAX_N = 100;
    final int MAX_C = 10000;
    
    
    private void solve() throws IOException {
	int n = nextInt();
	myAssert(MIN_N <= n && n <= MAX_N);
	double[] x = new double[n];
	double[] y = new double[n];
	for (int i = 0; i < n; ++i) {
	    x[i] = nextInt();
	    y[i] = nextInt();
	    myAssert(Math.abs(x[i]) <= MAX_C);
	    myAssert(Math.abs(y[i]) <= MAX_C);
	}
	
	if (getArea(x, y) < 0) {
	    reverse(x);
	    reverse(y);
	}
	checkConvex(x, y);
	
	double[] a = new double[n];
	double[] b = new double[n];
	double[] c = new double[n];
	
	for (int i = 0; i < n; ++i) {
	    int j = (i + 1) % n;
	    a[i] = y[i] - y[j];
	    b[i] = x[j] - x[i];
	    double d = Math.sqrt(a[i] * a[i] + b[i] * b[i]);
	    a[i] /= d;
	    b[i] /= d;
	    c[i] = - a[i] * x[i] - b[i] * y[i];
	}
	
	double[] tc = new double[n];
	double lR = 0;
	double rR = 100000;
	
	double[] cx = new double[n];
	double[] cy = new double[n];
	
	for (int q = 0; q < 50; ++q) {
	    double R = (lR + rR) / 2;
	    for (int i = 0; i < n; ++i) {
		tc[i] = c[i] - R;
	    }
	    
	    if (R < 1) {
		R += 0;
	    }
	    
	    boolean good = false;	    
	    for (int i = 0; i < n; ++i) {
		int m = 0;
		for (int j = 0; j < n; ++j) {
		    double p = a[i] * b[j] - a[j] * b[i];
		    if (Math.abs(p) < eps) continue;
		    cx[m] = (b[i] * tc[j] - tc[i] * b[j]) / p;
		    cy[m] = (tc[i] * a[j] - a[i] * tc[j]) / p;
		    ++m;
		}
		
		loop:
		for (int k = 0; k < m; ++k) {
		    for (int j = 0; j < n; ++j) {
			if (a[j] * cx[k] + b[j] * cy[k] + tc[j] < -eps) continue loop;
		    }
		    good = true;
		    break;
		}
	    }
	    
	    if (good) {
		lR = R;
	    } else {
		rR = R;
	    }
	}
	
	out.println(lR);
    }
    
    double eps = 1e-10;
    
    void reverse(double[] x) {
	for (int i = 0; 2 * i < x.length; ++i) {
	    double t = x[i];
	    x[i] = x[x.length - i - 1];
	    x[x.length - i - 1] = t;
	}
    }

    double getArea(double[] x, double[] y) {
	double ans = 0;
	int n = x.length;
	for (int i = 0; i < x.length; ++i) {
	    ans += x[i] * y[(i + 1) % n] - x[(i + 1) % n] * y[i];
	}
	return ans;
    }
    

    void checkConvex(double[] x, double[] y) {
	int n = x.length;
	myAssert(y.length == n);
	double ang = 0;
	for (int i = 0; i < n; ++i) {
	    int j = (i + 1) % n;
	    int k = (i + n - 1) % n;
	    double ux = x[j] - x[i];
	    double uy = y[j] - y[i];
	    double vx = x[i] - x[k];
	    double vy = y[i] - y[k];
	    double sin = vx * uy - vy * ux;
	    double cos = vx * ux + vy * uy;
	    myAssert(sin > 1e-9);
	    ang += Math.atan2(sin, cos);
	}
	
	myAssert(Math.abs(ang - 2 * Math.PI) < 1);
    }
    
}
