#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
#define int long long
#define double long double
const double eps=1e-8;
const double pi=acos(-1);
int sgn(double x){      //符号
    if(abs(x)<=eps)return 0;
    return x<0?-1:1;
}
struct Point{       //点与向量
    double x,y;
    Point(){}
    Point(double x,double y):x(x),y(y){}

    bool operator==(const Point&a)const{
        return (sgn(x-a.x)==0&&sgn(y-a.y)==0);
    }
    bool operator<(const Point&a)const{
        if(sgn(x-a.x)==0)return sgn(y-a.y)==-1;
        return sgn(x-a.x)==-1;
    }
    bool operator>(const Point&a)const{return !((*this<a)||(*this==a));}

    Point operator+(const Point&a)const{return {x+a.x,y+a.y};}
    Point operator-(const Point&a)const{return {x-a.x,y-a.y};}
    Point operator-()const{return {-x,-y};}
    Point operator*(double t)const{return {x*t,y*t};}
    Point operator/(double a)const{return {x/a,y/a};}
    void input(){cin>>x>>y;}

    double dot(const Point&a)const{return x*a.x+y*a.y;}        //点积
    double cross(const Point&a)const{return x*a.y-y*a.x;}      //叉积
    double len2()const{return dot(*this);}          //长度平方
    double len()const{return sqrt(len2());}         //长度
    int toleft(const Point&a)const{return sgn(cross(a));}    //当前向量到 a 是逆时针旋转

    double dis2(const Point&a)const{return ((*this)-a).len2();}     //两点距离平方
    double dis(const Point&a)const{return sqrt(dis2(a));}           //两点距离
};
typedef Point Vector;
struct Line{        //直线
    Point p;
    Vector v;
    Line(){}
    Line(Point p,Vector v):p(p),v(v){}
    double dis(Point a)const{return abs(v.cross(a-p)/v.len());}      //点到直线距离
    Point inter(const Line&a)const{     //两直线交点
        return p+v*((a.v.cross(p-a.p))/(v.cross(a.v)));
    }
    bool operator<(const Line&a)const{      // 直线极角排序，极角相同时靠左的在前
        if(sgn(atan2(v.y,v.x)-atan2(a.v.y,a.v.x))==0)return (a.p-p).cross(a.p+a.v-p)>0;
        else return atan2(v.y,v.x)<atan2(a.v.y,a.v.x);
    }
};
struct Segment{         //线段
    Point a,b;
    Segment(){}
    Segment(Point a,Point b):a(a),b(b){}
    bool operator<(const Segment &s)const{      //按左端点横坐标排序
        return make_pair(a,b)<make_pair(s.a,s.b);
    }
    double dis(const Point&p)const{     //点到线段距离
        if(sgn((p-a).dot(b-a))==-1||sgn((p-b).dot(a-b))==-1)return min(p.dis(a),p.dis(b));
        Point p0=a,v=b-a;
        return abs(v.cross(p-p0)/v.len());
    }
    // 判断点是否在线段上
    // -1 点在线段端点 | 0 点不在线段上 | 1 点严格在线段上
    int is_on(const Point&p)const{
        if(p==a || p==b)return -1;
        return (p-a).toleft(p-b)==0 && (p-a).dot(p-b)<-eps;
    }
};
struct Polygon{             //多边形
    vector<Point> p; //逆时针顺序存储
    int nxt(const int x)const{return x==(p.size()-1)?0:(x+1);}      //下个点
    int pre(const int x)const{return x==0?(p.size()-1):(x-1);}      //上个点
    double area()const{     //多边形面积，顺时针存点为负，逆时针存点为正
        double sum=0;
        for(int i=0;i<p.size();i++)
            sum+=p[i].cross(p[nxt(i)]);
        return sum/2;
    }
    double circ()const{     //多边形周长
        double sum=0;
        for(int i=0;i<p.size();i++)
            sum+=p[i].dis(p[nxt(i)]);
        return sum;
    }
};
struct Convex:Polygon{      //凸多边形
    double Calipers()const{        //凸包直径 (旋转卡壳)
        double ans=0;
        if(p.size()==2)return p[0].dis(p[1]);
        int now=0;
        for(int i=0;i<p.size();i++){
            Line l(p[i],p[i]-p[nxt(i)]);
            while(l.dis(p[now])<=l.dis(p[nxt(now)]))now=nxt(now);
            ans=max(ans,max(p[i].dis(p[now]),p[nxt(i)].dis(p[now])));
        }
        return ans;
    }
    // O(logn) 判断点是否在凸包内
    // -1 点在凸包边上 | 0 点在凸包外 | 1 点在凸包内
    int is_in(const Point a)const{
        if(p.size()==1)return a==p[0]?-1:0;
        if(p.size()==2)return Segment(p[0],p[1]).is_on(a)?-1:0;
        if(a==p[0])return -1;
        if((p[1]-p[0]).toleft(a-p[0])==-1 || (p.back()-p[0]).toleft(a-p[0])==1)return 0;
        auto cmp=[&](const Point&u,const Point&v){
            return (u-p[0]).toleft(v-p[0])==1;
        };
        int pos=lower_bound(p.begin()+1,p.end(),a,cmp)-p.begin();
        if(pos==1)return Segment(p[0],p[1]).is_on(a)?-1:0;
        if(pos==p.size()-1 && Segment(p[0],p[pos]).is_on(a))return -1;
        if(Segment(p[pos-1],p[pos]).is_on(a))return -1;
        return (p[pos]-p[pos-1]).toleft(a-p[pos-1])>0;
    }
    int get(const Point a,int op)const{     // op=1  极角序最大的切点   |   op=-1   极角序最小的切点
        int l=0,r=p.size()-1;
        auto cmp=[&](const Point&x,const Point&y){
            return (x-a).toleft(y-a)==op;
        };
        if(cmp(p[0],p.back())){     // 极值在 p[back]
            while(l<r){
                int mid=(l+r)>>1;
                if(cmp(p[r],p[mid]) && cmp(p[mid+1],p[mid]))r=mid;
                else l=mid+1;
            }
        }
        else{       // 极值在 p[0]
            while(l<r){
                int mid=(l+r+1)>>1;
                if(cmp(p[l],p[mid]) && cmp(p[mid-1],p[mid]))l=mid;
                else r=mid-1;
            }
        }
        return l;
    }
    // O(logn) 点到凸包切线，返回两个切点在凸包中的下标
    pair<int,int>get_tan(const Point&a)const{
        return {get(a,1),get(a,-1)};
    }
    // O(logn) 点到凸包距离
    double dis(const Point&a)const{
        if(is_in(a)==-1 || is_in(a)==1)return 0;
        if(p.size()==1)return p[0].dis(a);
        if(p.size()==2)return Segment(p[0],p[1]).dis(a);
        auto[mx,mn]=get_tan(a);
        double dis=min(Segment(p[mx],p[nxt(mx)]).dis(a),Segment(p[pre(mn)],p[mn]).dis(a));
        int op1=sgn((p[nxt(mx)]-p[mx]).dot(a-p[mx]));
        int op2=sgn((p[mn]-p[pre(mn)]).dot(a-p[pre(mn)]));
        if(mx!=mn && op1!=op2){
            int l=mx,r=mn-1;
            if(r<l)r+=p.size();
            while(l<r){
                int mid=(l+r+1)>>1,t=mid%p.size();
                int p1=sgn((p[nxt(t)]-p[t]).dot(a-p[t]));
                if(p1==op1)l=mid;
                else r=mid-1;
            }
            l%=p.size();
            dis=min(dis,Segment(p[l],p[nxt(l)]).dis(a));
        }
        return dis;
    }
};
Convex Andrew(vector<Point>p){
    vector<Point>st;
    Convex ans;
    sort(p.begin(), p.end());
    auto check=[&](const vector<Point>&st,Point u){
        Point tmp1=st.back(),tmp2=*prev(st.end(),2);
        return (tmp1-tmp2).toleft(u-tmp1)<=0;
    };
    for(auto u:p){
        while(st.size()>1 && check(st,u))st.pop_back();
        st.push_back(u);
    }
    int k=st.size();
    p.pop_back();
    reverse(p.begin(), p.end());
    for(auto u:p){
        while(st.size()>k && check(st,u))st.pop_back();
        st.push_back(u);
    }
    st.pop_back();
    ans.p=st;
    return ans;
}

void solve(){
    int n,m;
    cin>>n>>m;
    vector<Point>vec;
    for(int i=1;i<=n;i++){
        int x,y;
        cin>>x>>y;
        vec.emplace_back(x,y);
    }
    Convex con= Andrew(vec);
    while(m--){
        int x1,x2,y1,y2;
        cin>>x1>>y1>>x2>>y2;
        Point p1(x1,y1),p2(x2,y2);
        Point p=(p1+p2)/2;
        cout<<fixed<<setprecision(10)<<p.dis2(p1)/2.0l+con.dis(p)*con.dis(p)<<endl;
    }
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int Te=1;
//    cin>>Te;
    while(Te--){
        solve();
    }
}