#include <iostream>
#include <vector>
using namespace std;

struct punto{
    long double x,y;
    punto operator-(const punto b)const{
        punto aux;
        aux.x = x-b.x;
        aux.y = y-b.y;
        return aux;
    }
    long double operator^(const punto b)const{
        return (x*b.y - y*b.x);
    }
    punto operator*(double b)const{
        punto aux;
        aux.x = x*b;
        aux.y = y*b;
        return aux;
    }
    punto operator+(const punto b)const{
        punto aux;
        aux.x = x+b.x;
        aux.y = y+b.y;
        return aux;
    }
};

bool interseca(punto u, punto p1, punto v, punto p2){
    ///cout<<"tenemos el vector que corta = ("<<u.x<<","<<u.y<<"), que pasa por el punto ("<<p1.x<<","<<p1.y<<")"<<endl;
    ///cout<<"tenemos el vector lado del poligono= ("<<v.x<<","<<v.y<<"), que pasa por el punto ("<<p2.x<<","<<p2.y<<")"<<endl;

    double x = (double)( (u^p1) - (u^p2) ) / ((double)(u^v));
    ///cout<<"para este par, x = "<<x<<endl;
    return ( x >= 0.0 && x < 1.0);
}
punto interseccion(punto u, punto p1, punto v, punto p2){
    double x = (double)( (u^p1) - (u^p2) ) / ((double)(u^v));
    return (p2+v*x);
}


long long paralado(punto vec, punto p){
    return (vec.x*p.x + vec.y*p.y);
}

long double area( vector<punto>RTA ){
    long double rta = 0.0;
    int N = RTA.size();
    for(int i = 0; i < RTA.size(); i++){
            rta +=  RTA[ (i+1)%N] ^ RTA[i];
       ///punto vec2 = RTA[ (i+1)%N] - RTA[i];
    }

    return (rta/2.0);
}

int main(){

int N;
cin>>N;
vector<punto>V (N);
for(int i = 0; i < N; i++){
    punto p;
    cin>>p.x>>p.y;
    V[i] = p;
}

int Q;
cin>>Q;
for(int i = 0; i < Q; i++){
    punto a,b;
    cin>>a.x>>a.y>>b.x>>b.y;
    /// el vector va de a hacia b.
    punto vec = b-a;

    vector<int>R;
    for(int j = 0; j < N; j++){
            punto vec2 = V[ (j+1)%N] - V[j];
        if( interseca(vec,a,vec2,V[j]) ){
            R.push_back(j);
        }
    }

    vector<punto>RTA;
    if(R.size() == 2){
        /// interseca en dos puntos.
        punto vec2 = V[ (R[0]+1)%N] - V[R[0]];
        punto p1 = interseccion( vec,a,vec2,V[ R[0] ] );

        vec2 = V[ (R[1]+1)%N] - V[R[1]];
        punto p2 = interseccion( vec,a,vec2,V[ R[1] ] );

        /// tenemos los dos puntos de interseccion. hay que ver cual esta mas para el lado donde corta.

        if( paralado(vec,p1 ) > paralado(vec,p2) ){
            /// entonces empieza en a
            RTA.push_back(p1);
            for(int j = (R[0]+1)%N; j != R[1]; j = (j+1)%N ){
                RTA.push_back(V[j]);
            }
            RTA.push_back(V[ R[1] ]);
            RTA.push_back(p2);
        }else{
            /// entonces empieza en b
            RTA.push_back(p2);
            for(int j = (R[1]+1)%N; j != R[0]; j = (j+1)%N ){
                RTA.push_back(V[j]);
            }
            RTA.push_back(V[ R[0] ]);
            RTA.push_back(p1);

        }

    }else{
        /// o bien no interseca, y haay que ver de que lado estamos.
        /// o bien es paaralelo y pasa por un lado.
        punto p;
        bool lado = false;
        for(int j = 0; j < N; j++){
                punto vec2 = V[ (j+1)%N] - V[j];
            if( (vec^vec2) == 0 ){
                    /// el vector es paralelo a uno de los lados.
                    punto aux = V[j]-a;
                    if( aux.x * vec.y  == aux.y  *vec.x ){
                        /// en efecto es uno de los lados.
                        lado = true;
                        p = V[ (j+2)%N ];
                    }

            }
        }
        if(lado){
                ///cout<<"es lado"<<endl;


            if( (vec^ (p-a) ) > 0 ){
                ///cout<<"dio positivo con el punto "<<p.x<<" "<<p.y<<endl;
                for(int j = 0; j < N; j++){
                    RTA.push_back(V[j]);
                }
            }
        }else{
            ///cout<<"esta afuera"<<endl;
            /// asi y todo puede que coincida con uno de los puntos.
            if((vec^ (V[0]-a)) == 0){
                if( (vec^ (V[1]-a)) > 0 ){
                    for(int j = 0; j < N; j++){
                        RTA.push_back(V[j]);
                    }
                }
            }else{
                if( (vec^ (V[0]-a)) > 0 ){
                    for(int j = 0; j < N; j++){
                        RTA.push_back(V[j]);
                    }
                }
            }

        }

    }

    cout.precision(12);
    long double rta = -area(RTA);
    cout<<rta<<endl;


}

return 0;
}



Measured memory_bytes: 3320