#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=200005,M=200005,K=17,inf=~0U>>1;
int n,m,cq,i,xl,xr;
bool ans[M];
int idseg[K][N],idque[K][M];
struct P{
  int x,y;
  P(){}
  P(int _x,int _y){x=_x,y=_y;}
  P operator-(const P&b)const{return P(x-b.x,y-b.y);}
  P operator+(const P&b)const{return P(x+b.x,y+b.y);}
  ll operator*(const P&b)const{return 1LL*x*b.x+1LL*y*b.y;}
  bool operator==(const P&b)const{return x==b.x&&y==b.y;}
  void read(){scanf("%d%d",&x,&y);}
}a[N];
struct Line{
  P a,b;
  int xl,xr;
  int sx,sy,dx,dy;
  ll base;
  void fix(){
    if(a.x>b.x)swap(a,b);
    xl=a.x,xr=b.x;
    sx=a.x,sy=a.y,dx=b.x-a.x,dy=b.y-a.y;
    base=1LL*sy*dx-1LL*sx*dy;
  }
}seg[N],que[M];
struct Frac{
  ll u,d;
  Frac(){}
  Frac(ll _u,ll _d){
    u=_u,d=_d;
    if(d<0)u*=-1,d*=-1;
  }
  bool operator<(const Frac&b)const{return u*b.d<b.u*d;}
  bool operator>(const Frac&b)const{return u*b.d>b.u*d;}
  bool operator<=(const Frac&b)const{return u*b.d<=b.u*d;}
  bool operator>=(const Frac&b)const{return u*b.d>=b.u*d;}
}slo[M];
inline int sgn(ll x){
  if(x>0)return 1;
  return x?-1:0;
}
inline ll cross(const P&a,const P&b){return 1LL*a.x*b.y-1LL*a.y*b.x;}
inline void umin(int&a,int b){a>b?(a=b):0;}
inline void umax(int&a,int b){a<b?(a=b):0;}
inline Frac gety(const Line&a,int x){
  if(a.dx==0)return Frac(a.sy,1);
  return Frac(a.base+1LL*x*a.dy,a.dx);
}
inline bool point_on_segment(const P&p,const P&a,const P&b){
  return cross(b-a,p-a)==0&&(p-a)*(p-b)<=0;
}
inline bool has_intersection(const Line&A,const Line&B){
  if(!A.dx&&!A.dy)return point_on_segment(A.a,B.a,B.b);
  const P&a=A.a;
  const P&b=A.b;
  const P&p=B.a;
  const P&q=B.b;
  int d1=sgn(cross(b-a,p-a)),d2=sgn(cross(b-a,q-a));
  int d3=sgn(cross(q-p,a-p)),d4=sgn(cross(q-p,b-p));
  if(d1*d2<0&&d3*d4<0)return 1;
  if((d1==0&&point_on_segment(p,a,b))||
     (d2==0&&point_on_segment(q,a,b))||
     (d3==0&&point_on_segment(a,p,q))||
     (d4==0&&point_on_segment(b,p,q)))return 1;
  return 0;
}
namespace CaseWholeSeg{
int cnt,q[N];
inline void init(){cnt=0;}
inline void add(int x){q[++cnt]=x;}
inline bool cmpseg(int A,int B){
  const Line&p=seg[A];
  const Line&q=seg[B];
  int x=p.a==q.a?min(p.xr,q.xr):max(p.xl,q.xl);
  return gety(p,x)<gety(q,x);
}
inline void work(){sort(q+1,q+cnt+1,cmpseg);}
inline bool ask(const Line&p){
  int l=1,r=cnt,mid;
  while(l<=r){
    mid=(l+r)>>1;
    const Line&o=seg[q[mid]];
    if(has_intersection(p,o))return 1;
    int x=max(p.xl,o.xl);
    if(gety(p,x)<gety(o,x))r=mid-1;else l=mid+1;
  }
  return 0;
}
}
namespace CaseWholeQue{
int xl,xr;
int cs,idseg[N];
int cq,idque[M];
Frac yl[M],yr[M];
int cnt,cp,cl,cr,idl[N],idr[N];
P pool[N*2];
int ccur,chull;
struct Component{
  int st,en;
  bool isl,isr;
  Frac lmi,lma,rmi,rma;
  void upl(const Frac&b){
    if(!isl){
      isl=1;
      lmi=lma=b;
      return;
    }
    if(lmi>b)lmi=b;
    if(lma<b)lma=b;
  }
  void upr(const Frac&b){
    if(!isr){
      isr=1;
      rmi=rma=b;
      return;
    }
    if(rmi>b)rmi=b;
    if(rma<b)rma=b;
  }
}com[N];
struct Point{
  int x;Frac y;
  Point(){}
  Point(const P&b){x=b.x,y=Frac(b.y,1);}
  Point(int _x,const Frac&_y){x=_x,y=_y;}
}cur[N*2],hull[N*2];
inline bool cmpx(const P&a,const P&b){return a.x<b.x;}
inline void init(int _xl,int _xr){xl=_xl,xr=_xr;cs=cq=0;}
inline void addseg(int x){idseg[++cs]=x;}
inline void addque(int x){
  idque[++cq]=x;
  yl[x]=gety(que[x],xl);
  yr[x]=gety(que[x],xr);
}
inline Frac slope(const Point&a,const Point&b){//a.x<b.x
  return Frac(b.y.u*a.y.d-a.y.u*b.y.d,(b.x-a.x)*a.y.d*b.y.d);
}
namespace CaseLeft{
  inline bool cmpyl(int x,int y){return yl[x]<yl[y];}
  inline bool cmplma(int x,int y){return com[x].lma<com[y].lma;}
  inline bool cmplmi(int x,int y){return com[x].lmi>com[y].lmi;}
  inline void ext_down(int&n,Point*q,const Point&p){
    if(n&&q[n].x==p.x){
      if(q[n].y>=p.y)return;
      n--;
    }
    while(n>1&&slope(p,q[n])<=slope(q[n],q[n-1]))n--;
    q[++n]=p;
  }
  inline bool notin_down(const Point&p){
    if(chull<=1)return 1;
    if(p.x>hull[1].x)return 1;
    int l=2,r=chull-1,t=1;
    while(l<=r){
      int mid=(l+r)>>1;
      if(p.x==hull[mid].x)return p.y>=hull[mid].y;
      if(p.x>hull[mid].x)r=mid-1;else l=(t=mid)+1;
    }
    return slope(hull[t+1],p)>=slope(p,hull[t]);
  }
  inline void ext_up(int&n,Point*q,const Point&p){
    if(n&&q[n].x==p.x){
      if(q[n].y<=p.y)return;
      n--;
    }
    while(n>1&&slope(p,q[n])>=slope(q[n],q[n-1]))n--;
    q[++n]=p;
  }
  inline bool notin_up(const Point&p){
    if(chull<=1)return 1;
    if(p.x>hull[1].x)return 1;
    int l=2,r=chull-1,t=1;
    while(l<=r){
      int mid=(l+r)>>1;
      if(p.x==hull[mid].x)return p.y<=hull[mid].y;
      if(p.x>hull[mid].x)r=mid-1;else l=(t=mid)+1;
    }
    return slope(hull[t+1],p)<=slope(p,hull[t]);
  }
  inline void solve(){
    if(!cl)return;
    int i,j,k,A,B;
    sort(idque+1,idque+cq+1,cmpyl);
    sort(idl+1,idl+cl+1,cmplma);
    //left
    Frac minl;
    for(i=cq,j=cl;i;i--){
      A=idque[i];
      if(ans[A])continue;
      while(j){
        B=idl[j];
        if(com[B].lma<yl[A])break;
        if(j==cl)minl=com[B].lmi;
        else if(minl>com[B].lmi)minl=com[B].lmi;
        j--;
      }
      if(j<cl&&minl<=yl[A])ans[A]=1;
    }
    //down
    chull=0;
    for(i=j=1;i<=cq;i++){
      A=idque[i];
      if(ans[A])continue;
      while(j<=cl){
        B=idl[j];
        if(com[B].lma>=yl[A])break;
        ccur=0;
        if(com[B].isr)ext_down(ccur,cur,Point(xr,com[B].rma));
        for(k=com[B].en;k>=com[B].st;k--)ext_down(ccur,cur,pool[k]);
        ext_down(ccur,cur,Point(xl,com[B].lma));
        if(com[B].isr){
          chull=ccur;
          for(k=1;k<=ccur;k++)hull[k]=cur[k];
        }else{
          k=ccur;
          while(k>1&&notin_down(cur[k-1]))k--;
          while(chull&&hull[chull].x<=cur[k].x)chull--;
          for(;k<=ccur;k++)ext_down(chull,hull,cur[k]);
        }
        j++;
      }
      if(chull<=1)continue;
      int l=1,r=chull-1;
      if(hull[1].x==xr){
        if(hull[1].y>=yr[A]){
          ans[A]=1;
          continue;
        }
        if(chull==2)continue;
        l++;
      }
      int t=r--;
      const Frac&v=slo[A];
      //min slope(hull[t+1],hull[t]) >= v
      while(l<=r){
        int mid=(l+r)>>1;
        if(slope(hull[mid+1],hull[mid])>=v)r=(t=mid)-1;else l=mid+1;
      }
      if(slope(que[A].a,hull[t])>=slope(hull[t],que[A].b))ans[A]=1;
    }
    //up
    sort(idl+1,idl+cl+1,cmplmi);
    chull=0;
    for(i=cq,j=1;i;i--){
      A=idque[i];
      if(ans[A])continue;
      while(j<=cl){
        B=idl[j];
        if(com[B].lmi<=yl[A])break;
        ccur=0;
        if(com[B].isr)ext_up(ccur,cur,Point(xr,com[B].rmi));
        for(k=com[B].en;k>=com[B].st;k--)ext_up(ccur,cur,pool[k]);
        ext_up(ccur,cur,Point(xl,com[B].lmi));
        if(com[B].isr){
          chull=ccur;
          for(k=1;k<=ccur;k++)hull[k]=cur[k];
        }else{
          k=ccur;
          while(k>1&&notin_up(cur[k-1]))k--;
          while(chull&&hull[chull].x<=cur[k].x)chull--;
          for(;k<=ccur;k++)ext_up(chull,hull,cur[k]);
        }
        j++;
      }
      if(chull<=1)continue;
      int l=1,r=chull-1;
      if(hull[1].x==xr){
        if(hull[1].y<=yr[A]){
          ans[A]=1;
          continue;
        }
        if(chull==2)continue;
        l++;
      }
      int t=r--;
      const Frac&v=slo[A];
      while(l<=r){
        int mid=(l+r)>>1;
        if(slope(hull[mid+1],hull[mid])<=v)r=(t=mid)-1;else l=mid+1;
      }
      if(slope(que[A].a,hull[t])<=slope(hull[t],que[A].b))ans[A]=1;
    }
  }
}
namespace CaseRight{
  inline bool cmpyr(int x,int y){return yr[x]<yr[y];}
  inline bool cmprma(int x,int y){return com[x].rma<com[y].rma;}
  inline bool cmprmi(int x,int y){return com[x].rmi>com[y].rmi;}
  inline void ext_down(int&n,Point*q,const Point&p){
    if(n&&q[n].x==p.x){
      if(q[n].y>=p.y)return;
      n--;
    }
    while(n>1&&slope(q[n],p)>=slope(q[n-1],q[n]))n--;
    q[++n]=p;
  }
  inline bool notin_down(const Point&p){
    if(chull<=1)return 1;
    if(p.x<hull[1].x)return 1;
    int l=2,r=chull-1,t=1;
    while(l<=r){
      int mid=(l+r)>>1;
      if(p.x==hull[mid].x)return p.y>=hull[mid].y;
      if(p.x<hull[mid].x)r=mid-1;else l=(t=mid)+1;
    }
    return slope(hull[t],p)>=slope(p,hull[t+1]);
  }
  inline void ext_up(int&n,Point*q,const Point&p){
    if(n&&q[n].x==p.x){
      if(q[n].y<=p.y)return;
      n--;
    }
    while(n>1&&slope(q[n],p)<=slope(q[n-1],q[n]))n--;
    q[++n]=p;
  }
  inline bool notin_up(const Point&p){
    if(chull<=1)return 1;
    if(p.x<hull[1].x)return 1;
    int l=2,r=chull-1,t=1;
    while(l<=r){
      int mid=(l+r)>>1;
      if(p.x==hull[mid].x)return p.y<=hull[mid].y;
      if(p.x<hull[mid].x)r=mid-1;else l=(t=mid)+1;
    }
    return slope(hull[t],p)<=slope(p,hull[t+1]);
  }
  inline void solve(){
    if(!cr)return;
    int i,j,k,A,B;
    sort(idque+1,idque+cq+1,cmpyr);
    sort(idr+1,idr+cr+1,cmprma);
    //right
    Frac minl;
    for(i=cq,j=cr;i;i--){
      A=idque[i];
      if(ans[A])continue;
      while(j){
        B=idr[j];
        if(com[B].rma<yr[A])break;
        if(j==cr)minl=com[B].rmi;
        else if(minl>com[B].rmi)minl=com[B].rmi;
        j--;
      }
      if(j<cr&&minl<=yr[A])ans[A]=1;
    }
    //down
    chull=0;
    for(i=j=1;i<=cq;i++){
      A=idque[i];
      if(ans[A])continue;
      while(j<=cr){
        B=idr[j];
        if(com[B].rma>=yr[A])break;
        ccur=0;
        if(com[B].isl)ext_down(ccur,cur,Point(xl,com[B].lma));
        for(k=com[B].st;k<=com[B].en;k++)ext_down(ccur,cur,pool[k]);
        ext_down(ccur,cur,Point(xr,com[B].rma));
        if(com[B].isl){
          chull=ccur;
          for(k=1;k<=ccur;k++)hull[k]=cur[k];
        }else{
          k=ccur;
          while(k>1&&notin_down(cur[k-1]))k--;
          while(chull&&hull[chull].x>=cur[k].x)chull--;
          for(;k<=ccur;k++)ext_down(chull,hull,cur[k]);
        }
        j++;
      }
      if(chull<=1)continue;
      int l=1,r=chull-1;
      if(hull[1].x==xl){
        if(hull[1].y>=yl[A]){
          ans[A]=1;
          continue;
        }
        if(chull==2)continue;
        l++;
      }
      int t=r--;
      const Frac&v=slo[A];
      //min slope(hull[t],hull[t+1]) <= v
      while(l<=r){
        int mid=(l+r)>>1;
        if(slope(hull[mid],hull[mid+1])<=v)r=(t=mid)-1;else l=mid+1;
      }
      if(slope(que[A].a,hull[t])>=slope(hull[t],que[A].b))ans[A]=1;
    }
    //up
    sort(idr+1,idr+cr+1,cmprmi);
    chull=0;
    for(i=cq,j=1;i;i--){
      A=idque[i];
      if(ans[A])continue;
      while(j<=cr){
        B=idr[j];
        if(com[B].rmi<=yr[A])break;
        ccur=0;
        if(com[B].isl)ext_up(ccur,cur,Point(xl,com[B].lmi));
        for(k=com[B].st;k<=com[B].en;k++)ext_up(ccur,cur,pool[k]);
        ext_up(ccur,cur,Point(xr,com[B].rmi));
        if(com[B].isl){
          chull=ccur;
          for(k=1;k<=ccur;k++)hull[k]=cur[k];
        }else{
          k=ccur;
          while(k>1&&notin_up(cur[k-1]))k--;
          while(chull&&hull[chull].x>=cur[k].x)chull--;
          for(;k<=ccur;k++)ext_up(chull,hull,cur[k]);
        }
        j++;
      }
      if(chull<=1)continue;
      int l=1,r=chull-1;
      if(hull[1].x==xl){
        if(hull[1].y<=yl[A]){
          ans[A]=1;
          continue;
        }
        if(chull==2)continue;
        l++;
      }
      int t=r--;
      const Frac&v=slo[A];
      //min slope(hull[t],hull[t+1]) >= v
      while(l<=r){
        int mid=(l+r)>>1;
        if(slope(hull[mid],hull[mid+1])>=v)r=(t=mid)-1;else l=mid+1;
      }
      if(slope(que[A].a,hull[t])<=slope(hull[t],que[A].b))ans[A]=1;
    }
  }
}
inline void work(){
  if(!cs||!cq)return;
  int i,j,k,x;
  static int q[N];
  static bool vis[N],is[N];
  for(i=1;i<=cs;i++){
    x=idseg[i];
    is[x]=1;
    vis[x]=0;
  }
  cnt=cp=cl=cr=0;
  for(i=1;i<=cs;i++){
    x=idseg[i];
    if(vis[x])continue;
    cnt++;
    com[cnt].st=cp+1;
    com[cnt].isl=com[cnt].isr=0;
    vis[x]=1;
    int head=1,tail=1;
    q[1]=x;
    while(head<=tail){
      x=q[head++];
      const Line&p=seg[x];
      if(p.xl>xl&&p.xr<xr){
        pool[++cp]=p.a;
        pool[++cp]=p.b;
      }else if(p.xr<xr){
        if(p.xl==p.xr){
          com[cnt].upl(Frac(p.a.y,1));
          com[cnt].upl(Frac(p.b.y,1));
        }else{
          pool[++cp]=p.b;
          com[cnt].upl(gety(p,xl));
        }
      }else{
        if(p.xl==p.xr){
          com[cnt].upr(Frac(p.a.y,1));
          com[cnt].upr(Frac(p.b.y,1));
        }else{
          pool[++cp]=p.a;
          com[cnt].upr(gety(p,xr));
        }
      }
      for(j=x-1;j<=x+1;j+=2){
        k=j;
        if(k<0)k+=n;
        if(k>=n)k-=n;
        if(!is[k]||vis[k])continue;
        const P&v=j<x?a[x]:a[x+1];
        if(v.x<xl||v.x>xr)continue;
        vis[k]=1;
        q[++tail]=k;
      }
    }
    com[cnt].en=cp;
    if(com[cnt].isl)idl[++cl]=cnt;
    if(com[cnt].isr)idr[++cr]=cnt;
    sort(pool+com[cnt].st,pool+cp+1,cmpx);
  }
  for(i=1;i<=cs;i++)is[idseg[i]]=0;
  CaseLeft::solve();
  CaseRight::solve();
}
}
void solve(int o,int l,int r,int cs,int cq){
  if(l>=r||!cs||!cq)return;
  //Case 1: whole seg
  CaseWholeSeg::init();
  CaseWholeQue::init(l,r);
  for(int i=0;i<cs;i++){
    int id=idseg[o][i];
    int a=seg[id].xl,b=seg[id].xr;
    if(a<=l&&b>=r)CaseWholeSeg::add(id);
    else CaseWholeQue::addseg(id);
  }
  CaseWholeSeg::work();
  for(int i=0;i<cq;i++){
    int id=idque[o][i];
    int a=que[id].xl,b=que[id].xr;
    if(CaseWholeSeg::ask(que[id]))ans[id]=1;
    else if(a<=l&&b>=r)CaseWholeQue::addque(id);
  }
  //Case 2: whole query, partial seg
  CaseWholeQue::work();
  if(l+1==r)return;
  int mid=(l+r)>>1;
  for(int _=0;_<2;_++){
    int _l,_r,_cs=0,_cq=0;
    if(_==0)_l=l,_r=mid;else _l=mid,_r=r;
    for(int i=0;i<cs;i++){
      int id=idseg[o][i];
      int a=seg[id].xl,b=seg[id].xr;
      if(a<=l&&b>=r)continue;
      if(a>_r||b<_l)continue;
      idseg[o+1][_cs++]=id;
    }
    for(int i=0;i<cq;i++){
      int id=idque[o][i];
      if(ans[id])continue;
      int a=que[id].xl,b=que[id].xr;
      if(a<=l&&b>=r)continue;
      if(a>_r||b<_l)continue;
      idque[o+1][_cq++]=id;
    }
    solve(o+1,_l,_r,_cs,_cq);
  }
}
namespace CaseBothSameX{
int i,l,r,x,ce;
struct E{
  int x,y,v,p;
  E(){}
  E(int _x,int _y,int _v,int _p){x=_x,y=_y,v=_v,p=_p;}
}e[N+M];
inline bool cmpe(const E&a,const E&b){
  if(a.x!=b.x)return a.x<b.x;
  if(a.y!=b.y)return a.y<b.y;
  return a.p<b.p;
}
void solve(){
  for(i=0;i<cq;i++){
    x=idque[0][i];
    if(ans[x])continue;
    if(que[x].xl!=que[x].xr)continue;
    l=que[x].a.y,r=que[x].b.y;
    if(l>r)swap(l,r);
    e[ce++]=E(que[x].xl,r,l,x);
  }
  for(i=0;i<n;i++)if(a[i].x==a[i+1].x){
    l=a[i].y,r=a[i+1].y;
    if(l>r)swap(l,r);
    e[ce++]=E(a[i].x,l,r,-1);
  }
  sort(e,e+ce,cmpe);
  for(i=0;i<ce;i++){
    if(i==0||e[i].x!=e[i-1].x)r=-inf;
    if(e[i].p<0)umax(r,e[i].v);
    else if(r>=e[i].v)ans[e[i].p]=1;
  }
}
}
int main(){
  scanf("%d%d",&n,&m);
  xl=inf,xr=-inf;
  for(i=0;i<n;i++){
    a[i].read();
    umin(xl,a[i].x);
    umax(xr,a[i].x);
  }
  a[n]=a[0];
  for(i=0;i<n;i++){
    seg[i].a=a[i];
    seg[i].b=a[i+1];
    seg[i].fix();
    idseg[0][i]=i;
  }
  for(i=0;i<m;i++){
    que[i].a.read();
    que[i].b.read();
    que[i].fix();
    umax(que[i].xl,xl);
    umin(que[i].xr,xr);
    if(que[i].xl>que[i].xr)continue;
    if(que[i].xl==que[i].xr&&que[i].a.x!=que[i].b.x){
      if(que[i].xl==xl)que[i].a=que[i].b;
      else que[i].b=que[i].a;
      que[i].fix();
    }
    idque[0][cq++]=i;
    if(que[i].xl<que[i].xr)slo[i]=Frac(que[i].b.y-que[i].a.y,que[i].b.x-que[i].a.x);
  }
  solve(0,xl,xr,n,cq);
  CaseBothSameX::solve();
  for(i=0;i<m;i++)puts(ans[i]?"YES":"NO");
}