#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N=1e5+1e3+7;

int n;

struct P {
    int x,y;
    long double len() const
    {
        return hypotl(x,y);
    }
};

P operator -(const P &a,const P &b)
{
    return {a.x-b.x,a.y-b.y};
}

int det(const P &a,const P &b)
{
    return a.x*b.y-a.y*b.x;
}

bool operator <(const P &a,const P &b)
{
    return a.x<b.x||(a.x==b.x&&a.y<b.y);
}

bool operator ==(const P &a,const P &b)
{
    return a.x==b.x&&a.y==b.y;
}
bool operator !=(const P &a,const P &b)
{
    return a.x!=b.x||a.y!=b.y;
}
vector<P> conv(vector<P> pts)
{
    sort(pts.begin(),pts.end());
    vector<P> ret;
    for(auto p:pts)
    {
        while(ret.size()>1&&det(p-ret.back(),p-ret.end()[-2])>=0)
            ret.pop_back();
        ret.push_back(p);
    }
    reverse(pts.begin(),pts.end());
    int m=ret.size();
    for(auto p:pts)
    {
        while(ret.size()>m&&det(p-ret.back(),p-ret.end()[-2])>=0)
            ret.pop_back();
        ret.push_back(p);
    }
    ret.pop_back();
    return ret;
}

int in(vector<P> v,const P p)
{
    for(int i=0;i<3;i++)
    {
        if(det(v[(i+1)%3]-v[i],p-v[i])<0)
            return 0;
    }
    return 1;
}

int dot(const P &a,const P &b)
{
    return a.x*b.x+a.y*b.y;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    vector<P> v(n);
    for(auto &[x,y]:v)
        cin>>x>>y;
    long double ans=LONG_LONG_MAX;
    auto c=conv(v);
    if(c.size()<3)
    {
        cout<<"0\n";
    }
    set<P> cs(c.begin(),c.end());
    vector<vector<P> >ip(c.size());
    vector<vector<P> >ic(c.size());
    int m=c.size();
    for(auto p:v)
    {
        if(cs.find(p)!=cs.end())
            continue;
        int L=1,R=c.size();
        while(R-L>1)
        {
            int M=(L+R)>>1;
            if(det(c[M]-c[0],p-c[0])>=0)
                L=M;
            else
                R=M;
        }
        for(int i=L-1;i<=L+1;i++)
        {
            int j=(i%m+m)%m;
            if(!j)
                continue;
            if(in({c[(j+m-1)%m],c[j],c[(j+1)%m]},p))
                ip[j].push_back(p);
        }
        if(in({c[m-1],c[0],c[1]},p))
            ip[0].push_back(p);
    }
    for(int i=0;i<m;i++)
    {
        P u=c[(i+m-1)%m],v=c[(i+1)%m];
        ip[i].push_back(c[(i+m-1)%m]);
        ip[i].push_back(c[(i+1)%m]);
        ic[i]=conv(ip[i]);
        int j=0;
        while(ic[i][j]!=c[(i+m-1)%m])
            j++;
        rotate(ic[i].begin(),ic[i].begin()+j,ic[i].end());    
    }
    vector<long double> w(m,1e18);
    for(int i=0;i<m;i++)
    {
        P u=c[i],v=c[(i+1)%m];
        int l=(i+1)%m,r=(i+m-1)%m;
        if(l>r)
            r+=m;
        l--;
        while(r-l>1)
        {
            int mid=(l+r)>>1;
            if(det(v-u,c[mid%m]-u)>=det(v-u,c[(mid+1)%m]-u))
                r=mid;
            else
                l=mid;
        }
        int f=r%m;
        {
            int L=-1,R=(int)ic[f].size()-1;
            while(R-L>1)
            {
                int M=(L+R)>>1;
                if(det(v-u,ic[f][M]-u)>=det(v-u,ic[f][M+1]-u))
                    R=M;
                else
                    L=M;
            }
            ans=min(ans,(long double)det(v-u,ic[f][R]-u)/(v-u).len());
        }
        {
            for(int j=0;j+1<ic[i].size();j++)
            {
                P u=ic[i][j],v=ic[i][j+1];
                int L=(i+1)%m,R=(i+m-1)%m;
                if(L>R)
                    R+=m;
                L--;
                while(R-L>1)
                {
                    int M=(L+R)>>1;
                    if(det(v-u,c[M%m]-u)>=det(v-u,c[(M+1)%m]-u))
                        R=M;
                    else
                        L=M;
                }
                w[i]=min(w[i],(long double)det(v-u,c[R%m]-u)/(v-u).len()); 
            }
            ans=min(ans,w[i]);
        }
    }
    cout<<fixed<<setprecision(12)<<ans<<"\n";
}