#include <iostream>
#include <cmath>
#include <vector>

class Rational {
	using N = int;
	friend Rational operator*(const int &, const Rational &);
public:
	Rational(const N &p = 1, const N &q = 1) :num{ p }, den{ q } { tuubun(); };
	Rational(const Rational &p, const Rational &q) :Rational(p.num * q.den, p.den * q.num) {};
	bool operator<(const Rational &other) const {
		return num * other.den < den * other.num;
	}
	bool operator>(const Rational &other) const {
		return num * other.den > den * other.num;
	}
	bool operator==(const Rational &other) const {
		return num * other.den == den * other.num;
	}
	bool operator<=(const Rational &other) const { return (*this) < other || (*this) == other; }
	bool operator>=(const Rational &other) const { return (*this) > other || (*this) == other; }
	Rational operator*(const Rational &other) const {
		return Rational(num * other.num, den * other.den);
	}
	Rational operator+(const Rational &other) const {
		return Rational(num * other.den + other.num * den, den * other.den);
	}
	Rational operator-(const Rational &other) const {
		return Rational(num * other.den - other.num * den, den * other.den);
	}
	Rational operator/(const Rational &other) const {
		return Rational(num * other.den, den * other.num);
	}
	Rational operator-() const {
		return Rational(-num, den);
	}

private:
	N gcd(const N &a, const N &b) const {
		if (b == 0) {
			return a;
		}
		else {
			return gcd(b, a % b);
		}
	}
	void tuubun() {
		auto g = gcd(num, den);
		num /= g; den /= g;
		if (den < 0) {
			abs();
			num *= -1;
		}
	}
	void abs() {
		num = std::abs(num); den = std::abs(den);
	}
	N num, den;
};
Rational operator*(const int &n, const Rational &r) {
	return Rational(n * r.den + r.num, r.den);
};
struct Point {
	Point(const Rational &ax = 0, const Rational &ay = 0) :x{ ax }, y{ ay } {};
	Rational dist_square(const Point &other) const {
		auto dx{ x - other.x }, dy{ y - other.y };
		return dx * dx + dy * dy;
	}
	Rational x, y;
};
struct Line {
	Line(const Rational &aa = 1, const Rational &ab = 1, const Rational &ac = 1) :a{ aa }, b{ ab }, c{ ac } {};
	Line(const Point &p1, const Point &p2) :a( p2.y - p1.y ), b( p1.x - p2.x ), c( -p1.x * a - p1.y * b ) {};
	Line get_vertical() const {
		return Line(b, -a, 0);
	}
	Line shift_to_point(const Point &p) const {
		return Line(a, b, -(a * p.x + b * p.y));
	}
	bool is_paraller(const Line &other) const {
		return a * other.b == b * other.a;
	}
	Point cross_point(const Line &other) const {
		return Point((b * other.c - c * other.b) / (a * other.b - b * other.a), (c * other.a - a * other.c) / (a * other.b - b * other.a));
	}
	Rational distance_square(const Point &other) const {
		auto num = a * other.x + b * other.y + c;
		return Rational(num * num, a * a + b * b);
	}
	Rational a, b, c;
};
struct Circle {
	Circle(const int &x = 0, const int &y = 0, const int &ar = 0) :center{ x, y }, r{ ar } {};
	bool is_in(const Point &other) const {
		return center.dist_square(other) <= r * r;
	}
	Point center;
	int r;
};
int main() {
	for (int n; std::cin >> n && n != 0;) {
		std::vector<Circle> walls(n);
		for (auto &w : walls) {
			int wx, wy, r;
			std::cin >> wx >> wy >> r;
			w = Circle(wx, wy, r);
		}
		int m;
		std::cin >> m;
		for (; m > 0; --m) {
			int x, y;
			std::cin >> x >> y;
			Point tarou(x, y);
			std::cin >> x >> y;
			Point oni(x, y);
			Line view(tarou, oni);
			Line measure = view.get_vertical();
			bool is_danger = true;
			for (const auto &wall : walls) {
				auto nearest = measure.shift_to_point(wall.center).cross_point(view);
				if (wall.is_in(nearest) && !(wall.is_in(tarou) && wall.is_in(oni))) {
					if ((tarou.x - nearest.x) * (oni.x - nearest.x) < 0 || (tarou.y - nearest.y) * (oni.y - nearest.y) < 0) {
						is_danger = false;
						break;
					}
					else if (wall.is_in(tarou) || wall.is_in(oni)){
						is_danger = false;
						break;
					}
				}
			}
			if (is_danger) {
				std::cout << "Danger\n";
			}
			else {
				std::cout << "Safe\n";
			}
		}
	}
}