#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-6)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1 
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0

using namespace std;

class Point{
public:
  double x,y;

  Point(double x = 0,double y = 0): x(x),y(y){}
  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 a){return Point(a*x,a*y);}
  Point operator / (double a){return Point(x/a,y/a);}
  Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
  bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
  bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }
};

struct Segment{
  Point p1,p2;
  Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
  bool operator <  (const Segment& s) const { return ( p2 == s.p2 ) ? p1 < s.p1 : p2 < s.p2; }
  bool operator == (const Segment& s) const { return ( s.p1 == p1 && s.p2 == p2 ) || ( s.p1 == p2 && s.p2 == p1 ); }
};

typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }

int ccw(Point p0,Point p1,Point p2){
  Point a = p1-p0;
  Point b = p2-p0;
  if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
  if(cross(a,b) < -EPS)return CLOCKWISE;
  if(dot(a,b) < -EPS)return ONLINE_BACK;
  if(norm(a) < norm(b))return ONLINE_FRONT;
  return ON_SEGMENT;
}

bool intersectSS(Line s, Line t) {
  return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
         ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
  return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality
}

Point crosspoint(Line l,Line m){
  double A = cross(l.p2-l.p1,m.p2-m.p1);
  double B = cross(l.p2-l.p1,l.p2-m.p1);
  if(abs(A) < EPS && abs(B) < EPS){
    vector<Point> vec;
    vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
    sort(vec.begin(),vec.end());
    return vec[1];
  }
  if(abs(A) < EPS)assert(false);
  return m.p1 + (m.p2-m.p1)*(B/A);
}

double cross3p(Point p,Point q,Point r) { return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x); }
bool collinear(Point p,Point q,Point r) { return fabs(cross3p(p,q,r)) < EPS; }
bool ccwtest(Point p,Point q,Point r)   { return cross3p(p,q,r) > 0; }
 bool onSegment(Point p,Point q,Point r){
  return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}

double angle(Point a,Point b,Point c) {
  double ux = b.x - a.x, uy = b.y - a.y;
  double vx = c.x - a.x, vy = c.y - a.y;
  return acos((ux*vx + uy*vy)/sqrt((ux*ux + uy*uy) * (vx*vx + vy*vy)));
}  
  
bool inPolygon(Polygon poly,Point p){
  if((int)poly.size() == 0)return false;
  rep(i,poly.size()) if(onSegment(poly[i],poly[(i+1)%poly.size()],p))return true;
  double sum = 0;
  for(int i=0; i < (int)poly.size() ;i++) {
    if( equals(cross(poly[i]-p,poly[(i+1)%poly.size()]-p),0.0) ) continue;
    if( cross3p(p,poly[i],poly[(i+1)%poly.size()]) < 0 ) sum -= angle(p,poly[i],poly[(i+1)%poly.size()]);
    else                                                 sum += angle(p,poly[i],poly[(i+1)%poly.size()]);
  }
  const double eps = 1e-5;
  return (fabs(sum - 2*M_PI) < eps || fabs(sum + 2*M_PI) < eps);
}  

struct Edge {
  int from,to,rev;
  double cost;
  Edge(int from=0,int to=0,int rev=-1,double cost=0):from(from),to(to),rev(rev),cost(cost){}
  bool operator < (const Edge& a)const { return !equals(cost,a.cost) && cost < a.cost; }
};

vector<vector<Edge> > segmentArrangement(vector<Segment> vs,vector<Point> &ps) {

  rep(i,vs.size()) REP(j,i+1,vs.size()) if(intersectSS(vs[i],vs[j])) ps.push_back(Point(crosspoint(vs[i],vs[j])));
  sort(ps.begin(),ps.end());
  ps.erase(unique(ps.begin(),ps.end()),ps.end());
  vector<vector<Edge> > ret(ps.size());

  for(int i=0;i<vs.size();i++){
    vector<pair<double,int> > list;
    rep(j,ps.size()) if(intersectSP(vs[i],ps[j]))list.push_back(pair<double,int>(norm(vs[i].p1-ps[j]),j));
    sort(list.begin(),list.end());
    for(int j=0;j+1<list.size();++j) {
      int from = list[j].second, to = list[j+1].second;
      double cost = abs(ps[from]-ps[to]);
      ret[from].push_back(Edge(from,to,-1,cost));
      ret[to].push_back(Edge(to,from,-1,cost));
    }
  }  
  return ret;
}


const int MAX_V = 5000;
bool visited[MAX_V][MAX_V];
vector<vector<Edge> > G;
vector<Point> vp;

bool getPath(int start_node,int node,int edge,vector<Point> &buf){
  if( visited[node][edge] ){
    if( !buf.empty() && node == start_node ) return true;
    return false;
  }
  visited[node][edge] = true;
 
  int next_node = G[node][edge].to;
  int next_edge = (G[node][edge].rev+1)%((int)G[next_node].size());
  buf.push_back(vp[G[node][edge].from]);
  if(getPath(start_node,next_node,next_edge,buf)) return true;
  else return visited[node][edge] = false;
}

bool insideCC(Point a,double ra,Point b,double rb){
  double d = sqrt(norm(a-b));
  double r1 = max(ra,rb);
  double r2 = min(ra,rb);
  
  if(!equals(d,r1-r2) && d < r1-r2) return ra < rb; 
  return false;
}

bool intersectCC(Point a,double ra,Point b,double rb){
  double d = sqrt(norm(a-b));
  double r1 = max(ra,rb);
  double r2 = min(ra,rb);
  if(!equals(d,r1+r2) && d > r1+r2)return false;
  if(!equals(d,r1-r2) && d < r1-r2)return false;  // verify
  return true;
}

bool  LT(double a,double b) { return !equals(a,b) && a < b; }
bool LTE(double a,double b) { return  equals(a,b) || a < b; }

bool insideCP(Point a,double ra,Point b) { return LTE(abs(a-b),ra); }

const int MAX_N = 200;
const int MAX_M = 20;
int n,m;
Point cp[MAX_N],P[MAX_M],Q[MAX_M];
double r[MAX_N];
int answer[MAX_M];

void compute_exceptional_case() {
  
  // case 1 : circle <= circle and compress circles firmly
  bool isInside[n];
  rep(i,n) isInside[i] = false;
  rep(i,n) rep(j,n) if( i != j && insideCC(cp[i],r[i],cp[j],r[j]) ) { isInside[i] = true; break; }
  rep(i,m) {
    rep(j,n) if( isInside[j] && ( insideCP(cp[j],r[j],P[i]) || insideCP(cp[j],r[j],Q[i]) ) ) {
      answer[i] = ( insideCP(cp[j],r[j],P[i]) && insideCP(cp[j],r[j],Q[i]) );
      break;
    }
  }

  for(int i=n-1;i>=0;i--) if( isInside[i] ) { // compress
    --n;
    swap(cp[i],cp[n]);
    swap( r[i], r[n]);
  }

  // case 2 : P and Q on common area of two circles
  rep(i,m) if( answer[i] == -1 ){
    vector<int> info[2];
    rep(j,n) {
      if( insideCP(cp[j],r[j],P[i]) ) info[0].push_back(j);
      if( insideCP(cp[j],r[j],Q[i]) ) info[1].push_back(j);
    }
    assert( info[0].size() <= 2 && info[1].size() <= 2 );
    if( info[0].size() == 2 || info[1].size() == 2  ) answer[i] = ( info[0] == info[1] );
  }

  // P and Q on any circle
  rep(i,m) if( answer[i] == -1 ) {
    rep(j,n) {
      bool res1 = insideCP(cp[j],r[j],P[i]);
      bool res2 = insideCP(cp[j],r[j],Q[i]);
      if( res1 || res2 ) { answer[i] = ( res1 && res2 ); break; }
    }
  }
  
}

Point vir;
bool comp_angle(const Edge &a,const Edge &b){ return LT(atan2(vir.y-vp[a.to].y,vir.x-vp[a.to].x),atan2(vir.y-vp[b.to].y,vir.x-vp[b.to].x)); }

void compute(){

  compute_exceptional_case();
  /*
  cout << "n = " << n << endl;
  rep(i,n) cout << cp[i] << ", " << r[i] << endl;
  */

  bool fin = true;
  rep(i,m) if( answer[i] == -1 ) { fin = false; break; }
  if( fin ) return;


  vector<Segment> segs;
  rep(i,n) rep(j,n) if( i != j && intersectCC(cp[i],r[i],cp[j],r[j]) ) segs.push_back(Segment(cp[i],cp[j]));
  rep(i,segs.size()) if( !( segs[i].p1 < segs[i].p2 ) ) swap(segs[i].p1,segs[i].p2);
  sort(segs.begin(),segs.end());  
  segs.erase(unique(segs.begin(),segs.end()),segs.end());

  //cout << "segs---------" << endl;
  //rep(i,segs.size()) cout << segs[i] << endl;

  vp.clear();
  G = segmentArrangement(segs,vp);
  rep(i,(int)G.size()) {
    vir = vp[i];
    sort(G[i].begin(),G[i].end(),comp_angle);
  }


  rep(i,(int)G.size()) rep(j,(int)G[i].size()) if( G[i][j].rev == -1 ){
    int s = G[i][j].from, t = G[i][j].to;
    rep(k,(int)G[t].size()) if( G[t][k].to == s ){
      G[i][j].rev = k;
      G[t][k].rev = j;
    }
  }

  assert( (int)G.size() < MAX_V );
  rep(i,(int)G.size()) rep(j,(int)G[i].size()) { visited[i][j] = false; assert( (int)G[i].size() < MAX_V ); }
  vector<Polygon> polies;
  rep(i,(int)G.size()) rep(j,(int)G[i].size()) {
    vector<Point> buf;
    if( getPath(i,i,j,buf) ) polies.push_back(buf);
  }
  
  rep(i,m) if( answer[i] == -1 ) {
    vector<int> tmp1,tmp2;
    rep(j,polies.size()) {
      if( inPolygon(polies[j],P[i]) ) tmp1.push_back(j);
      if( inPolygon(polies[j],Q[i]) ) tmp2.push_back(j);
    }
    answer[i] = ( tmp1 == tmp2 );
  }
    
}

int main(){
  while( cin >> n >> m, n|m ){
    rep(i,n) cin >> cp[i].x >> cp[i].y >> r[i];
    rep(i,m) cin >> P[i].x >> P[i].y >> Q[i].x >> Q[i].y;
    rep(i,m) answer[i] = -1;
    compute();
    rep(i,m) {
      if(i) printf(" ");
      cout << (answer[i]?"YES":"NO");
    } puts("");
  }
  return 0;
}

Measured memory_bytes: 1724