#include <fstream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;

class TPoint
{
    public:
        long long ComputeSquareDistance(TPoint ptSecond);

        TPoint(int iNewX,int iNewY);
        ~TPoint();

        bool operator() (TPoint ptFirst, TPoint ptSecond)
        {
            return ((ptFirst.iX<ptSecond.iX)||((ptFirst.iX==ptSecond.iX)&&(ptFirst.iY<ptSecond.iY)));
        }

        friend ostream &operator<<(ostream &fOutput, TPoint &ptPoint)
        {
            fOutput << ptPoint.iX<<" "<<ptPoint.iY<<endl;

            return fOutput;
        }

        int iX,iY;

    private:

    protected:
};

class TPointsArray
{
    public:
        int AddPoint(int iX,int iY);

        long long ComputeClosestsPoints();

        friend ostream &operator<<(ostream &fOutput, TPointsArray & objArray)
        {
            std::vector <TPoint>::iterator * itIndex;

            //for (itIndex=objArray->m_vPoints.begin(); itIndex<objArray->m_vPoints.end(); ++itIndex)
                //fOutput << *itIndex.<< " ";

            return fOutput;
        }
    private:

    protected:
        std::vector <TPoint> m_vPoints;

};
//----------------------------------------
//--------------TPoint--------------------
//----------------------------------------
long long TPoint::ComputeSquareDistance(TPoint ptSecond)
{
    return ((ptSecond.iX - this->iX) *1LL* (ptSecond.iX - this->iX) +
           (ptSecond.iY - this->iY) *1LL* (ptSecond.iY - this->iY));
}
//----------------------------------------
TPoint::TPoint(int iNewX, int iNewY)
{
    this->iX=iNewX;
    this->iY=iNewY;
}
//----------------------------------------
TPoint::~TPoint()
{

}
//----------------------------------------
//------------TPointsArray-------------------
//----------------------------------------
int TPointsArray::AddPoint(int iX,int iY)
{
    this->m_vPoints.push_back(TPoint(iX,iY));
    return this->m_vPoints.size();
}
//----------------------------------------
long long TPointsArray::ComputeClosestsPoints()
{
    sort(m_vPoints.begin(),m_vPoints.end(),m_vPoints[0]);
    long long lldSmallestDistance,lldDistance;

    lldSmallestDistance = m_vPoints[0].ComputeSquareDistance(m_vPoints[m_vPoints.size()-1]);

    for (int i = 0; i < this->m_vPoints.size()-1; i++)
        for (int j = i + 1; j < this->m_vPoints.size(); j++)
        {
            lldDistance = m_vPoints[i].ComputeSquareDistance(m_vPoints[j]);

            if (1LL*(m_vPoints[i].iX - m_vPoints[j].iX) * (m_vPoints[i].iX - m_vPoints[j].iX) > lldSmallestDistance)
                break;

            if (lldDistance < lldSmallestDistance)
                lldSmallestDistance = lldDistance;
        }

    return lldSmallestDistance;
}
//----------------------------------------
//----------------------------------------
//----------------------------------------
int ReadData(TPointsArray * objPointsArray)
{
    FILE * fIn = fopen("cmap.in","r");

    int iCount;
    fscanf(fIn,"%d",&iCount);
    int iX,iY;

    for (int i=0; i<iCount; i++)
    {
        fscanf(fIn,"%d %d",&iX,&iY);
        objPointsArray->AddPoint(iX,iY);
    }

    fclose(fIn);

    return 1;
}
//----------------------------------------
void Solve(FILE * fOut, TPointsArray * objPointsArray)
{
    fprintf(fOut,"%.6lf", sqrt (objPointsArray->ComputeClosestsPoints()));
}
//----------------------------------------
int main()
{
    TPointsArray * objPointsArray = new TPointsArray();
    ReadData(objPointsArray);

    FILE * fOut = fopen("cmap.out","w");
    Solve(fOut,objPointsArray);
    fclose(fOut);

    return 0;
}