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

namespace Geo2D{
	typedef long long int ll;
	const double eps = 1e-8;
	const double pi = acos(-1);
	const double inf = 1e100;
	/* Be careful for the criteria for == two doubles */
	/* Relative or Absolute? */
	struct Double{
		double x;
		Double(double x=0):x(x){}
		Double(const Double& rhs){x=rhs.x;}
		Double operator+(const Double& rhs)const{return Double(x+rhs.x);}
		Double& operator+=(const Double& rhs){return x+=rhs.x,*this;}
		Double operator-(const Double& rhs)const{return Double(x-rhs.x);}
		Double& operator-=(const Double& rhs){return x-=rhs.x,*this;}
		Double operator*(const Double& rhs)const{return Double(x*rhs.x);}
		Double& operator*=(const Double& rhs){return x*=rhs.x,*this;}
		Double operator/(const Double& rhs)const{return Double(x/rhs.x);}
		Double& operator/=(const Double& rhs){return x/=rhs.x,*this;}
		Double operator-()const{return Double(-x);}
		Double operator^(const Double& rhs)const{return pow(x,rhs.x);}
		Double operator^(const int& rhs)const{
			double res = 1, base = x;
			int b = rhs;
			while(b){
				if(b&1)	res = res * base;
				b >>= 1;
				base *= base;
			}
			return res;
		}
		Double& operator++(){return ++x,*this;}
		Double& operator--(){return --x,*this;}
		Double operator++(int){Double res(x);return x++,res;}
		Double operator--(int){Double res(x);return x--,res;}
		bool operator==(const Double& rhs)const{return x+eps>=rhs.x&&x<=rhs.x+eps;}
		bool operator!=(const Double& rhs)const{return !(*this==rhs);}
		bool operator<(const Double& rhs)const{return (*this==rhs)?false:x<rhs.x;}
		bool operator>(const Double& rhs)const{return (*this==rhs)?false:x>rhs.x;}
		bool operator<=(const Double& rhs)const{return (*this==rhs)?true:x<rhs.x;}
		bool operator>=(const Double& rhs)const{return (*this==rhs)?true:x>rhs.x;}
		friend ostream & operator << (ostream& os, const Double& rhs){
			os << rhs.x;
			return os;
		}
		friend istream & operator >> (istream& is, Double& rhs){
			is >> rhs.x;
			return is;
		}
		friend Double abs(const Double& rhs){return abs(rhs.x);}
		friend Double sin(const Double& rhs){return sin(rhs.x);}
		friend Double cos(const Double& rhs){return cos(rhs.x);}
		friend Double tan(const Double& rhs){return tan(rhs.x);}
		friend Double asin(const Double& rhs){return asin(rhs.x);}
		friend Double acos(const Double& rhs){return acos(rhs.x);}
		friend Double atan(const Double& rhs){return atan(rhs.x);}
		friend Double atan2(const Double& lhs,const Double& rhs){return atan2(lhs.x,rhs.x);}
		friend Double sqrt(const Double& rhs){return sqrt(rhs.x);}
		friend ll ceil(const Double& rhs){return ceil(rhs.x);}
		friend ll round(const Double& rhs){return round(rhs.x);}
		friend ll floor(const Double& rhs){return floor(rhs.x);}
		friend int sign(const Double& rhs){return (rhs<0)?(-1):(rhs>0);}
	};
	typedef Double T;
	/* To change a point, do P = P.member_function() */
	struct Point{
		T x,y;
		Point(T x=0,T y=0):x(x),y(y){}
		bool operator<(const Point& rhs)const{return x==rhs.x?y<rhs.y:x<rhs.x;}
		bool operator==(const Point& rhs)const{return x==rhs.x&&y==rhs.y;}
		Point operator-()const{return Point(-x,-y);}
		Point operator+(const Point& rhs)const{return Point(x+rhs.x,y+rhs.y);}
		Point operator-(const Point& rhs)const{return Point(x-rhs.x,y-rhs.y);}
		T operator*(const Point& rhs)const{return x*rhs.x+y*rhs.y;}
		Point operator*(const T& rhs)const{return Point(x*rhs,y*rhs);}
		Point operator/(const T& rhs)const{return Point(x/rhs,y/rhs);}
		T operator^(const Point& rhs)const{return x*rhs.y-y*rhs.x;}
		Double len()const{return sqrt(x*x+y*y);}
		T len2()const{return x*x+y*y;}
		Double dist(const Point& rhs)const{Point delta = *this - rhs;return delta.len();}
		T dist2(const Point& rhs)const{Point delta = *this - rhs;return delta.len2();}
		Point norm()const{Double l = len();return *this/l;}
		Point resize(Double l)const{return norm()*l;}
		Point rotpos()const{return Point(-y,x);}
		Point rotneg()const{return Point(y,-x);}
		Point rot(const Double& ang)const{return Point(x*cos(ang)-y*sin(ang),y*cos(ang)+x*sin(ang));}
		/* friend function */
		/* the angle of ABC <= 180 */
		friend Double angle(const Point& A,const Point& B,const Point& C){
			return abs(atan2(abs((A-B)^(C-B)),(A-B)*(C-B)));
		}
		friend ostream & operator << (ostream& os, const Point& rhs){
			os << rhs.x << ' ' << rhs.y;
			return os;
		}
		friend istream & operator >> (istream& is, Point& rhs){
			is >> rhs.x >> rhs.y;
			return is;
		}
		/* this function will modify v */
		/* ans should be inf when calling this function */
		friend void closet_pair(vector<Point> &v,int l,int r,Double& ans,bool sorted=false){
			static vector<Point> tmp;
			if(r+1>tmp.size())	tmp.resize(r+1);
			if(!sorted)	sort(v.begin(),v.end());
			if(r-l<=3){
				for(int i=l;i<=r;i++)
					for(int j=i+1;j<=r;j++)
						ans=min(ans,v[i].dist(v[j]));
				sort(v.begin()+l,v.begin()+r+1,[&](Point &A,Point &B){return A.y<B.y;});
				return;
			}
			int mid=(l+r)>>1;
			Double d=v[mid].x;
			closet_pair(v,l,mid,ans,true),closet_pair(v,mid+1,r,ans,true);
			merge(v.begin()+l,v.begin()+mid+1,v.begin()+mid+1,v.begin()+r+1,tmp.begin(),[&](Point &A,Point &B){return A.y<B.y;});
			copy(tmp.begin(),tmp.begin()+r-l+1,v.begin()+l);
			int sz=0;
			for(int i=l;i<=r;i++)
				if(abs(v[i].x-d)<ans){
					for(int j=sz-1;j>=0&&v[i].y-tmp[j].y<ans;j--)
						ans=min(ans,v[i].dist(tmp[j]));
					tmp[sz++]=v[i];
				}
		}
	};
	/* (-pi,pi] */
	Double norm(Double ang){
		ang = ang-round(ang/pi/2)*pi*2;
		if(ang<=-pi)	ang+=2*pi;
		if(ang>pi)	ang-=2*pi;
		return ang;
	}
	struct Line{
		Point s,e;
		Line(Point s=Point(),Point e=Point()):s(s),e(e){}
		Line(Point p,Double ang):s(p){
			ang=norm(ang);
			if(ang==pi/2)	e=s+Point(0,1);
			else if(ang==-pi/2)	e=s-Point(0,1);
			else	e=s+Point(1,tan(ang));
		}
		/* ax+by+c==0 */
		Line(Double a,Double b,Double c){
			if(a==0){
				s=Point(0,-c/b);
				e=Point(1,-c/b);
			}
			else if(b==0){
				s=Point(-c/a,0);
				e=Point(-c/a,1);
			}
			else{
				s=Point(0,-c/b);
				e=Point(-c/a,0);
			}
		}
		bool operator==(const Line& rhs)const{return s==rhs.s&&e==rhs.e;}
		bool operator<(const Line& rhs)const{return s==rhs.s?e<rhs.e:s<rhs.s;}
		Double len()const{return s.dist(e);}
		T len2()const{return s.dist2(e);}
		Double angle()const{return atan2(e.y-s.y,e.x-s.x);}
		Point projection(const Point& p)const{
			return s+((e-s)*((e-s)*(p-s)))/(e-s).len2();
		}
		Point symmetry(const Point& p)const{
			return projection(p)*2-p;
		}
		/* -1: at left, 0: on line, 1: at right */
		int where(const Point& p)const{
			auto x = (p-s)^(e-s);
			if(x==0)	return 0;
			else if(x>0)	return 1;
			else return -1;
		}
		/* 0: parallel, 1: same, 2: orthogonal, 3: intersect */
		int relation(const Line& l)const{
			if(parallel(l))	return where(l.s)==0;
			else if(orthogonal(l))	return 2;
			else return 3;
		}
		bool onseg(const Point& p)const{return ((p-s)^(e-s))==0&&((p-s)*(p-e))<=0;}
		bool parallel(const Line& l)const{return ((e-s)^(l.e-l.s))==0;}
		bool orthogonal(const Line& l)const{return ((e-s)*(l.e-l.s))==0;}
		/* 0: no intersection, 1: not normal, 2: normal */
		/* *this is line, l is seg */
		int linecrossseg(const Line& l)const{
			int d0 = sign((e-s)^(l.s-s));
			int d1 = sign((e-s)^(l.e-s));
			if((d0^d1)==-2)	return 2;
			return d0==0||d1==0;
		}
		/* 0: no intersection, 1: not normal, 2: normal */
		int segcrossseg(const Line& l)const{
			int d0 = sign((e-s)^(l.s-s));
			int d1 = sign((e-s)^(l.e-s));
			int d2 = sign((l.e-l.s)^(s-l.s));
			int d3 = sign((l.e-l.s)^(e-l.s));
			if((d0^d1)==-2&&(d2^d3)==-2)	return 2;
			return (d0==0&&onseg(l.s))||(d1==0&&onseg(l.e))||(d2==0&&l.onseg(s))||(d3==0&&l.onseg(e));
		}
		Double distasline(const Point& p)const{return abs(((p-s)^(e-s))/len());}
		Double distasseg(const Point& p)const{
			if(((p-s)*(e-s))<0||((p-e)*(s-e))<0)
				return min(s.dist(p),e.dist(p));
			return distasline(p);
		}
		/* both are segs */
		Double distsegseg(const Line& l)const{
			if(segcrossseg(l)!=0)	return 0;
			return min(min(distasseg(l.s),distasseg(l.e)),min(l.distasseg(s),l.distasseg(e)));
		}
		/* *this is line */
		Double distlineseg(const Line& l)const{
			if(linecrossseg(l)==0)
				return min(distasline(l.s),distasline(l.e));
			return 0;
		}

		friend ostream & operator << (ostream& os, const Line& rhs){
			os << rhs.s << ' ' << rhs.e;
			return os;
		}
		friend istream & operator >> (istream& is, Line& rhs){
			is >> rhs.s >> rhs.e;
			return is;
		}
		friend Point intersectLL(const Line& l,const Line& r){
			Double s1=(r.e-r.s)^(l.s-r.s), s2=-((r.e-r.s)^(l.e-r.s));
			return (l.s*s2+l.e*s1)/(s1+s2);
		}
	};
	struct Circle{
		Point o;
		Double r;
		Circle(Point o=Point(),Double r=0):o(o),r(r){}
		Circle(Double x,Double y,Double r):o(Point(x,y)),r(r){}
		bool operator==(const Circle& rhs)const{return o==rhs.o&&r==rhs.r;}
		bool operator<(const Circle& rhs)const{return o<rhs.o||(o==rhs.o&&r<rhs.r);}
		Double area()const{return r*r*pi;}
		Double circum()const{return r*pi*2;}
		/* -1: in, 0: on, 1: out */
		int relation(const Point& rhs)const{
			Double d=o.dist(rhs);
			if(d<r)	return -1;
			if(d==r)	return 0;
			else return 1;
		}
		/* -1: somewhere inside, 0: intersect once, 1: totally outside */
		int relationseg(const Line& rhs)const{
			Double d=rhs.distasseg(o);
			if(d<r)	return -1;
			if(d==r)	return 0;
			else return 1;
		}
		/* -1: somewhere inside, 0: tangent, 1: totally outside */
		int relationline(const Line& rhs)const{
			Double d=rhs.distasline(o);
			if(d<r)	return -1;
			if(d==r)	return 0;
			else return 1;
		}
		/* -3: equal
		   -2: contain
		   -1: in tangent
		    0: intersect
		    1: ex tangent
		    2: separate */
		int relation(const Circle& rhs)const{
			if(*this==rhs)	return -3;
			Double d=o.dist(rhs.o), l=abs(r-rhs.r);
			if(d>r+rhs.r)	return 2;
			if(d==r+rhs.r)	return 1;
			if(d>l)	return 0;
			if(d==l)	return -1;
			return -2;
		}
		Double area(const Circle& rhs)const{
			int rel = relation(rhs);
			if(rel>=1)	return 0;
			if(rel<=-1)	return min(area(),rhs.area());
			Double d=o.dist(rhs.o);
			Double a1=acos((r*r+d*d-rhs.r*rhs.r)/(d*r*2));
			Double a2=acos((rhs.r*rhs.r+d*d-r*r)/(d*rhs.r*2));
			return r*r*a1+rhs.r*rhs.r*a2-r*d*sin(a1);
		}
		friend ostream & operator << (ostream& os, const Circle& rhs){
			os << rhs.o << ' ' << rhs.r;
			return os;
		}
		friend istream & operator >> (istream& is, Circle& rhs){
			is >> rhs.o >> rhs.r;
			return is;
		}
		friend vector<Point> intersectCL(const Circle& C,const Line& L){
			int rel=C.relationline(L);
			Point proj=L.projection(C.o);
			if(rel==1)	return {};
			else if(rel==0)	return {proj};
			else{
				Double d=L.distasline(C.o);
				d=sqrt(C.r*C.r-d*d);
				vector<Point> res;
				res.emplace_back(proj+(L.e-L.s).resize(d));
				res.emplace_back(proj-(L.e-L.s).resize(d));
				if(res[1]<res[0])
					swap(res[0],res[1]);
				return res;
			}
		}
		/* be careful for two identical circles */
		friend vector<Point> intersectCC(const Circle& Cl,const Circle& Cr){
			int rel=Cl.relation(Cr);
			if(rel<=-2||rel>=2)	return {};
			Double d=Cl.o.dist(Cr.o);
			Double l=(d*d+Cl.r*Cl.r-Cr.r*Cr.r)/(d*2);
			Double h=sqrt(Cl.r*Cl.r-l*l);
			Point proj=Cl.o+(Cr.o-Cl.o).resize(l);
			Point i1=proj+(Cr.o-Cl.o).rotneg().resize(h);
			Point i2=proj+(Cr.o-Cl.o).rotpos().resize(h);
			if(rel!=0)	return {i1};
			if(i1<i2)	return {i1,i2};
			else		return {i2,i1};
		}
		/* the first point is always P */
		/* the order is ccw about vector(PT)*/
		friend vector<Line> tangentCP(const Circle& C,const Point& P){
			int rel=C.relation(P);
			if(rel==-1)	return {};
			if(rel==0)	return {Line(P,P+(P-C.r).rotpos())};
			Double d=P.dist(C.o);
			Double l=C.r*C.r/d;
			Double h=sqrt(C.r*C.r-l*l);
			Point i1=C.o+(P-C.o).resize(l)+(P-C.o).rotneg().resize(h);
			Point i2=C.o+(P-C.o).resize(l)+(P-C.o).rotpos().resize(h);
			return {Line(P,i1),Line(P,i2)};
		}
		/* order is ccw with respect to Cl */
		/* first point is on Cl */
		friend vector<Line> extanCC(const Circle& Cl,const Circle& Cr){
			int rel=Cl.relation(Cr);
			if(rel<-1)	return {};
			if(Cl.r==Cr.r){
				Point dir=Cr.o-Cl.o;
				dir=dir.rotpos().resize(Cl.r);
				return {Line(Cl.o-dir,Cr.o-dir),Line(Cl.o+dir,Cr.o+dir)};
			}
			Point p=(Cl.o*(-Cr.r)+Cr.o*Cl.r)/(Cl.r-Cr.r);
			vector<Line> resl=tangentCP(Cl,p),resr=tangentCP(Cr,p);
			if(resl.size()==1)
				return resl;
			else
				return {Line(resl[0].e,resr[0].e),Line(resl[1].e,resr[1].e)};
		}
		/* order is ccw with respect to Cl */
		/* first point is on Cl */
		friend vector<Line> intanCC(const Circle& Cl,const Circle& Cr){
			int rel=Cl.relation(Cr);
			if(rel<=0)	return {};
			Point p=(Cl.o*Cr.r+Cr.o*Cl.r)/(Cl.r+Cr.r);
			vector<Line> resl=tangentCP(Cl,p),resr=tangentCP(Cr,p);
			if(resl.size()==1)
				return resl;
			else
				return {Line(resl[0].e,resr[0].e),Line(resl[1].e,resr[1].e)};
		}
	};

	/* Triangle Centers */
	Point incenter(const Point& A,const Point& B,const Point& C){
		auto a=(B-C).len(),b=(A-C).len(),c=(A-B).len();
		return (A*a+B*b+C*c)/(a+b+c);
	}
	Point circenter(const Point& A,const Point& B,const Point& C){
		Line u((A+B)/2,(A+B)/2+(B-A).rotpos());
		Line v((A+C)/2,(A+C)/2+(C-A).rotpos());
		return intersectLL(u,v);
	}
	Point masscenter(const Point& A,const Point& B,const Point& C){
		return (A+B+C)/3;
	}
	Point orthocenter(const Point& A,const Point& B,const Point& C){
		return masscenter(A,B,C)*3-circenter(A,B,C)*2;
	}

	/* not necessary convex */
	struct Polygon:vector<Point>{
		bool isconvex()const{
			bool flagl=false,flagr=false;
			for(int i=0;i<size();i++){
				int j=(i+1)%size(),k=(j+1)%size();
				auto z=(at(i)-at(j))^(at(k)-at(j));
				if(z<0)	flagl=true;
				if(z>0)	flagr=true;
				if(flagl&&flagr)	return false;
			}
			return true;
		}
		/* negative then clockwise, ccw if positive */
		T area2()const{
			T res=0;
			for(int i=0;i<size();i++)
				res+=(at(i)^at((i+1)%size()));
			return res;
		}
		Double area()const{return abs(area2())/2;}
		Double circum()const{
			Double res=0;
			for(int i=0;i<size();i++)
				res+=at(i).dist(at((i+1)%size()));
			return res;
		}
		/* 3: as vertex, 2: onseg, 1: interior, 0: exterior */
		int relation(const Point& p)const{
			int n=size();
			for(int i=0;i<n;i++)
				if(p==at(i))
					return 3;
			int cnt=0;
			for(int i=0;i<n;i++){
				Point s=at(i),e=at((i+1)%n);
				if(Line(s,e).onseg(p))	return 2;
				if(s.y-e.y>0)	s=at((i+1)%n),e=at(i);
				if(p.y>=e.y||p.y<s.y)	continue;
				if(Line(s,e).where(p)==-1)	cnt++;
			}
			return cnt&1;
		}
	};
	struct Convex:Polygon{
		/* P should contain at least two "different" points */
		/* ccw, first point is defined by sort */
		Convex(vector<Point> P={},bool border=false){
			if(P.size()<=1){
				clear();
				return;
			}
			sort(P.begin(),P.end());
			emplace_back(P[0]),emplace_back(P[1]);
			for(int i=2;i<P.size();i++){
				if(border)
					while(size()>=2&&((back()-at(size()-2))^(P[i]-at(size()-2)))<0)
						pop_back();
				else
					while(size()>=2&&((back()-at(size()-2))^(P[i]-at(size()-2)))<=0)
						pop_back();
				emplace_back(P[i]);
			}
			for(int i=P.size()-2,t=size();i>=0;i--){
				if(border)
					while(size()>t&&((back()-at(size()-2))^(P[i]-at(size()-2)))<0)
						pop_back();
				else
					while(size()>t&&((back()-at(size()-2))^(P[i]-at(size()-2)))<=0)
						pop_back();
				emplace_back(P[i]);
			}
			pop_back();
			if(size()<=1||(size()==2&&at(0)==at(1)))	clear();
		}
		Double diameter()const{
			if(size()<=1)	return 0;
			if(size()==2)	return at(0).dist(at(1));
			int n=size(),q=1;
			Double res=0;
			const vector<Point> &v=*this;
			for(int i=0;i<n;i++){
				int j=(i+1)%n;
				while(((v[j]-v[i])^(v[q]-v[i]))<((v[j]-v[i])^(v[(q+1)%n]-v[i])))
					q=(q+1)%n;
				res=max(res,max(v[i].dist(v[q]),v[j].dist(v[(q+1)%n])));
			}
			return res;
		}
		/* get the left hand side of the convex polygon */
		Convex cut(const Line& l)const{
			Convex res;
			for(int i=0,n=size();i<n;i++){
				int p=l.where(at(i)),q=l.where(at((i+1)%n));
				if(p<=0)	res.emplace_back(at(i));
				if(p*q<0)	res.emplace_back(intersectLL(l,Line(at(i),at((i+1)%n))));
			}
			return res;
		}
		bool inconvex(const Point& p)const{
			const vector<Point>& c=*this;
			int L=1,R=c.size()-1;
			if(((p-c[0])^(c[L]-c[0]))>0)	return false;
			if(((p-c[0])^(c[R]-c[0]))<0)	return false;
			while(L<R){
				int mid=(L+R+1)>>1;
				if(((p-c[0])^(c[mid]-c[0]))<=0)	L=mid;
				else	R=mid-1;
			}
			if(L==c.size()-1)	L--;
			return ((p-c[L])^(c[L+1]-c[L]))<=0;
		}
		/* Minkowski Sum */
		/* ccw, call hull for Pp,Pq beforehand */
		Convex operator+(const Convex& rhs)const{
			Convex Pr;
			const Convex& Pp = *this;
			const Convex& Pq = rhs;
			int n=Pp.size(),m=Pq.size();
			Pr.emplace_back(Pp[0]+Pq[0]);
			for(int i=0,j=0;i!=n||j!=m;){
				Point nxt;
				if((j==m)||(i!=n&&((Pp[(i+1)%n]-Pp[i])^(Pq[(j+1)%m]-Pq[j]))>=0)){
					nxt=Pr.back()+Pp[(i+1)%n]-Pp[i];
					i++;
				}
				else{
					nxt=Pr.back()+Pq[(j+1)%m]-Pq[j];
					j++;
				}
				while(Pr.size()>=2&&((Pr.back()-nxt)^(Pr[Pr.size()-2]-nxt))==0)
					Pr.pop_back();
				Pr.emplace_back(nxt);
			}
			return Pr.pop_back(),Pr;
		}
		Convex& operator+=(const Convex& rhs){return *this = *this + rhs,*this;}
	};
}
/* End of Geo2D */

using namespace Geo2D;

/* LightOJ 1203: angle
int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int T;
	cin>>T;
	for(int t=1;t<=T;t++){
		double ans = inf;
		int n;
		cin>>n;
		vector<Point> res(n);
		for(int i=0;i<n;i++)
			cin>>res[i].x>>res[i].y;
		res = hull(res);
		if(res.empty())	ans = 0;
		else{
			for(int i=0;i<res.size();i++){
				int j =(i+1)%res.size(),k=(j+1)%res.size();
				ans = min(ans,angle(res[i],res[j],res[k]));
			}
		}
		cout<<fixed<<setprecision(10);
		cout<<"Case "<<t<<": "<<ans/pi*180<<endl;
	}
}
*/

/* LibreOJ 2549 */
/*
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n, m, q;
    cin >> n >> m >> q;
    vector<Point> Pp(n), Pq(m);
    for (int i = 0; i < n; i++) cin >> Pp[i];
    for (int i = 0; i < m; i++) {
        cin >> Pq[i];
        Pq[i]=-Pq[i];
    }
    Convex c = Convex(Pp)+Convex(Pq);
    while (q--) {
        Point P;
        cin >> P;
        cout << c.inconvex(P) << '\n';
    }
}
*/



/* Aizu CGL 1 A */
/* Aizu CGL 1 B */
/*
int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	Point s,e;
	cin>>s.x>>s.y>>e.x>>e.y;
	Line L(s,e);
	int q;
	cin>>q;
	while(q--){
		Point p;
		cin>>p.x>>p.y;
		// p = L.projection(p);
		p = L.symmetry(p);
		cout<<fixed<<setprecision(15)<<p.x<<' '<<p.y<<'\n';
	}
}
*/
int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin>>n;
	vector<Point> v(n);
	for(int i=0;i<n;i++)
		cin>>v[i];
	Double ans=inf;
	closet_pair(v,0,n-1,ans);
	cout<<fixed<<setprecision(15)<<ans<<endl;
}



Measured memory_bytes: 6108