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

using db = long double;
const db Eps = 1e-9;
const db Pi = 4 * atan(1.0L);
#define op operator

int sgn(db a, db b = 0) {
	a -= b;
	return (a > Eps) - (a < -Eps);
}

struct poi {
	db x, y;
	void r() { cin >> x >> y; }
	void w() { cout << x << ' ' << y << '\n'; }
	poi op -(poi p) {
		return {x - p.x, y - p.y};
	}
	poi op +(poi p) {
		return {x + p.x, y + p.y};
	}
	poi op *(db d) {
		return {x * d, y * d};
	}
	poi op /(db d) {
		return {x / d, y / d};
	}
	db dot(poi p) {
		return x * p.x + y * p.y;
	}
	db cross(poi p) {
		return x * p.y - y * p.x;
	}
	poi rot90() {
		return {-y, x};
	}
	db arg() {
		db r = atan2(y, x);
		if(sgn(r) < 0) r += 2 * Pi;
		return r;
	}
};

db xmul(poi a, poi b, poi c) {
	return (b - a).cross(c - a);
}

poi li(poi a, poi b, poi c, poi d) {
	db u = xmul(c, d, a), v = xmul(c, d, b);
	return (a * v - b * u) / (v - u);
}

pair <poi, poi> cc(poi c1, db r1, poi c2, db r2) {
	db x = (c1 - c2).dot(c1 - c2);
	db y = ((r1 * r1 - r2 * r2) / x + 1) / 2;
	db d = max(r1 * r1 / x - y * y, 0.0L);
	poi p1 = c1 + (c2 - c1) * y;
	poi p2 = ((c2 - c1) * sqrt(d)).rot90();
	return {p1 - p2, p1 + p2};
}
pair <db, db> cc_arg(poi c1, db r1, poi c2, db r2){
	auto p = cc(c1, r1, c2, r2);
	db a1 = (p.first - c1).arg(), a2 = (p.second - c1).arg();
	if(sgn(a1, a2) > 0) a2 += 2 * Pi; return {a1, a2};
}

struct HashCmp {
	bool operator ()(poi a, poi b) const {
		if(sgn(a.x, b.x) == 0)
			return sgn(a.y, b.y) < 0;
		return sgn(a.x, b.x) < 0;
	}
};

const int N = 111;
poi o[N];
db r[N];

int main() {
	cout << fixed << setprecision(6);
	//ios :: sync_with_stdio(false);
	int n, m;
	while(cin >> n >> m) {
		if(!n && !m) break;
		for(int i = 0; i < n; i ++) {
			o[i].r(); cin >> r[i];
		}

		vector <pair <poi, poi>> edges;
		for(int i = 0; i < n; i ++) {
			//cout << i << '\n';
			bool overlap = false;
			for(int j = 0; j < n; j ++) if(r[j] > r[i]) {
				if((r[j] - r[i]) * (r[j] - r[i]) > (o[j] - o[i]).dot(o[j] - o[i]))
					overlap = true;
			}
			if(overlap) continue;

			vector <db> v;
			set <poi, HashCmp> ignore;
			for(int j = 0; j < n; j ++) {
				if((r[j] - r[i]) * (r[j] - r[i]) < (o[j] - o[i]).dot(o[j] - o[i]) &&
					(r[j] + r[i]) * (r[j] + r[i]) > (o[j] - o[i]).dot(o[j] - o[i])) {
					auto inter = cc(o[i], r[i], o[j], r[j]);
					auto inter_arg = cc_arg(o[i], r[i], o[j], r[j]);
					ignore.insert(inter.first * 233 + inter.second);
					v.push_back(inter_arg.first);
					v.push_back(inter_arg.second);
				}
			}
			if(!v.size()) continue;
			sort(v.begin(), v.end());
			//cout << "------\n" << i << '\n';
			for(int j = 0; j < v.size(); j ++) {
				poi a = o[i] + poi{cos(v[j]), sin(v[j])} * r[i];
				poi b = o[i] + poi{cos(v[(j + 1) % v.size()]), sin(v[(j + 1) % v.size()])} * r[i];
				if(!ignore.count(a * 233 + b)) {
					edges.push_back({b, a});
					//b.w();
					//a.w();
				}
			}
		}
		map <poi, int, HashCmp> disc;
		vector <poi> old;
		for(auto p : edges) {
			disc[p.first] = 0;
			disc[p.second] = 0;
		}
		{
			int a = 0;
			for(auto &p : disc) {
				p.second = old.size();
				old.push_back(p.first);
			}
		}
		vector <int> to(old.size(), 0);
		for(auto p : edges) {
			to[disc[p.first]] = disc[p.second];
			//cout << "------\n";
			//p.first.w(); p.second.w();
			//cout << disc[p.first] << ' ' << disc[p.second] << '\n';
		}
		vector <vector <poi>> polys;
		vector <bool> vis(old.size(), false);
		for(int i = 0; i < old.size(); i ++) if(!vis[i]) {
			vector <poi> v = {old[i]}; vis[i] = true;
			for(int j = to[i]; j != i; j = to[j]) {
				vis[j] = true;
				v.push_back(old[j]);
			}
			db area = 0;
			for(int i = 0; i < v.size(); i ++)
				area += v[i].cross(v[(i + 1) % v.size()]);
			if(sgn(area) > 0)
				polys.push_back(v);
		}

		/*
		for(auto v : polys) {
			cout << "------\n";
			for(poi p : v) {
				p.w();
			}
		}
		*/

		auto check_cirs = [&](poi p) {
			vector <int> v;
			for(int i = 0; i < n; i ++)
				if((p - o[i]).dot(p - o[i]) < r[i] * r[i])
					v.push_back(i);
			return v;
		};
		auto check_polys = [&](poi p) {
			int ret = -1;
			poi q = poi{1e8L, 1e8L + 1} + p;
			for(int i = 0; i < polys.size(); i ++) {
				auto &v = polys[i];
				int n = v.size();
				int cnt = 0;
				for(int i = 0; i < n; i ++) {
					poi inter = li(p, q, v[i], v[(i + 1) % n]);
					if((inter - p).dot(q - p) > 0 &&
						xmul(p, q, v[i]) * xmul(p, q, v[(i + 1) % n]) < 0)
						cnt ++;
				}
				if(cnt & 1)
					ret = i;
			}
			return ret;
		};

		for(int i = 0; i < m; i ++) {
			poi q1, q2; q1.r(); q2.r();
			auto v1 = check_cirs(q1);
			auto v2 = check_cirs(q2);
			//for(auto x : v1) cout << x << ' '; cout << '\n';
			//for(auto x : v2) cout << x << ' '; cout << '\n';
			if(v1.size() || v2.size()) {
				cout << (v1 == v2 ? "YES" : "NO") << (i == m - 1 ? '\n' : ' ');
			} else {
				int pid1 = check_polys(q1);
				int pid2 = check_polys(q2);
				cout << (pid1 == pid2 ? "YES" : "NO") << (i == m - 1 ? '\n' : ' ');
			}
		}
	}
	return 0;
}

Measured memory_bytes: 3580