Kd tree

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

#define sc( x ) scanf( "%d" , &x )
#define REP( i , n ) for( int i = 0 ; i < n ; ++i )
#define clr( t , val ) memset( t , val , sizeof( t ) )

#define pb push_back
#define all( v ) v.begin() , v.end()
#define SZ( v ) ((int)(v).size())

#define mp make_pair
#define fi first
#define se second

#define N 4000000

#define sqr(A) ((A)*(A))

double eps = 1e-8;
int cmp (double a , double b = 0 ){
    return a + eps < b ? -1 : a - eps > b ? 1 : 0 ;
}

struct point {
    double x , y ;
    point (double a , double b ) : x ( a ) , y ( b ){ }
    point () {}
    point operator + ( point p ){ return point ( x + p.x , y + p.y ) ; }
    point operator - ( point p ){ return point ( x - p.x , y - p.y ) ; }
    point operator * ( double t ){ return point ( x * t , y * t ) ; }
    double operator * ( point p ){ return x * p.x + y * p.y ; }
    double operator % ( point p ){ return x * p.y - y * p.x ; }
    bool operator == ( point p ){ return cmp ( x , p.x ) == 0 && cmp ( y , p.y ) == 0 ; }
    bool operator < ( point p ) const{
        int t = cmp ( x , p . x ) ;
        if ( t ) return t < 0 ;
        return cmp ( y , p . y ) < 0 ;
    }

} ;

point T[ N ];
int le[ N ] ,ri[ N ];

bool compx( const point &A , const point &B ){
    return A.x<B.x;
}
bool compy( const point &A , const point &B ){
    return A.y < B.y;
}

//intervalocerrado[from,to]
inline int make( int from , int to , bool byx = true ){
    if( from > to ) return -1;
    if( from == to ){
        le[ from ] = ri[ from ] = -1;
        return from;
    }
    int mid=(from+to)/2;
    nth_element( T + from , T + mid , T + to + 1 , byx ? compx : compy );
    le[ mid ] = make( from , mid - 1 , !byx );
    ri[ mid ] = make( mid + 1 , to , !byx );
    return mid;
}

point p;
int dist;

//busco la distancia al nodo mas cercano de p.
//dist tiene q ser puesta en inf antes de hacer la query.
void query( int node , bool bxy ){
    if( node == -1 ) return;
    int distnode = sqr( T[ node ].x - p.x ) + sqr( T[ node ].y - p.y );
    dist = min( dist , distnode );
    if( bxy ){
        int len = sqr( T[ node ].x - p.x );
        if( compx( T[ node ] , p ) ){
            query( ri[ node ] , !bxy );
            if( len <= dist )
                query( le[ node ] , !bxy );
        }else{
            query( le[ node ] , !bxy );
            if( len <= dist )
                query( ri[ node ] , !bxy );
        }
    }else{
        int len = sqr( T[ node ].y - p.y );
        if( compy( T[ node ] , p ) ){
        query( ri[ node ] , !bxy );
        if( len <= dist )
            query( le[ node ] , !bxy );
        }else{
            query( le[ node ] , !bxy );
            if( len <= dist )
                query( ri[ node ] , !bxy );
        }
    }
}
/*
3
0 0
1 1
2 2

0 2
*/
int main(){
    int n;
    cin >> n;
    REP( i , n ) cin >> T[ i ].x >> T[ i ].y;
    make( 0 , n - 1 );
    dist = 1<<30;
    double x , y;
    cin >> x >> y;
    p = point( x , y );
    query( 0 , 1 );
    cout << dist << endl;
}