Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	x := make([]int, 100)
	y := make([]int, 100)
	r := make([]int, 100)
	for scanner.Scan() {
		a, _ := strconv.Atoi(scanner.Text())
		if a == 0 {
			break
		}
		for i := 0; i < a; i++ {
			scanner.Scan()
			input := strings.Split(scanner.Text(), " ")
			tmpx, _ := strconv.Atoi(input[0])
			tmpy, _ := strconv.Atoi(input[1])
			tmpr, _ := strconv.Atoi(input[2])
			x[i], y[i], r[i] = tmpx, tmpy, tmpr
		}
		scanner.Scan()
		b, _ := strconv.Atoi(scanner.Text())
		for i := 0; i < b; i++ {
			scanner.Scan()
			input := strings.Split(scanner.Text(), " ")
			c, _ := strconv.Atoi(input[0])
			d, _ := strconv.Atoi(input[1])
			e, _ := strconv.Atoi(input[2])
			f, _ := strconv.Atoi(input[3])
			ok := false
			for j := 0; j < a; j++ {
				if (c-x[j])*(c-x[j])+(d-y[j])*(d-y[j]) >= r[j]*r[j] || (e-x[j])*(e-x[j])+(f-y[j])*(f-y[j]) >= r[j]*r[j] {
					if (e-c)*(x[j]-c)+(f-d)*(y[j]-d) < 0 {
						if (x[j]-c)*(x[j]-c)+(y[j]-d)*(y[j]-d) <= r[j]*r[j] {
							ok = true
						}
					} else {
						if (e-c)*(x[j]-c)+(f-d)*(y[j]-d)>(e-c)*(e-c)+(f-d)*(f-d) {
							if (x[j]-e)*(x[j]-e)+(y[j]-f)*(y[j]-f)<=r[j]*r[j] {
								ok = true
							}
						} else {
							if (x[j]-c)*(x[j]-c)+(y[j]-d)*(y[j]-d)-((e-c)*(x[j]-c)+(f-d)*(y[j]-d))*((e-c)*(x[j]-c)+(f-d)*(y[j]-d))/((e-c)*(e-c)+(f-d)*(f-d))<=r[j]*r[j] {
								ok = true
							}
						}
					}

				}
			}
			if ok {
				fmt.Println("Safe")
			} else {
				fmt.Println("Danger")
			}
		}
	}
}

C++: #include <iostream>
#include <vector>
#include <map>
#include <stack>
#include <list>
#include <queue>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <math.h>

#define NITENKAN(a, b) sqrt(((a.first - b.first) * (a.first - b.first)) + ((a.second - b.second) * (a.second - b.second)))

using namespace std;

bool checkFound(pair<double, double> taro, pair<double, double> oni, pair<pair<double, double>, double> syougai){
	double ac = NITENKAN(syougai.first, oni);
	double ab = NITENKAN(taro, oni);
	double bc = NITENKAN(syougai.first, taro);

	if(ac >= ab || bc >= ab){
		return true;
	}

	double naiseki =  (taro.first - oni.first) * (syougai.first.first - oni.first) + (taro.second - oni.second) * (syougai.first.second - oni.second);
	double cosSita = naiseki / (ab * ac);
	double t = ac * (1 - cosSita);//(sita * 3.14 / 180.0));
	t *= syougai.second;

	if(t > syougai.second){
		return true;
	}
	else{
		return false;
	}
}

int main(){
	int n = 0;

	while(cin >> n && n != 0){
		int m = 0;
		bool danger = false;
		vector<pair<pair<double, double>, double>> syougai(n);

		for(int i = 0; i < n; i++){
			cin >> syougai[i].first.first >> syougai[i].first.second >> syougai[i].second;
		}
		
		cin >> m;
		vector<pair<double, double>> taro(m);
		vector<pair<double, double>> oni(m);
		for(int j = 0; j < m; j++){
			//cinと比較、結果出力を書く
			cin >> taro[j].first >> taro[j].second >> oni[j].first >> oni[j].second;

			//太郎と鬼の現在位置における各障害物の影響を見る
			for(int l = 0; l < n; l++){
				//二人共円内
				if((NITENKAN(taro[j], syougai[l].first) < syougai[l].second) && (NITENKAN(oni[j], syougai[l].first) < syougai[l].second)){
					//円内に円がある可能性があるので他の障害物の影響を見る
					for(int a = l + 1; a < n; a++){
						danger = checkFound(taro[j], oni[j], syougai[a]);
						if(!danger){
							break;
						}
					}
				}
				//二人共円外
				else if((NITENKAN(taro[j], syougai[l].first) > syougai[l].second) &&  (NITENKAN(oni[j], syougai[l].first) > syougai[l].second)){
					danger = checkFound(taro[j], oni[j], syougai[l]);
				}
				else{
					danger = false;
				}
				if(!danger){
					break;		
				}
			}

			if(!danger){
				cout << "Safe" << endl;
			}
			else{
				cout << "Danger" << endl;
			}

		}
	}
}

C++: #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 dist = view.distance_square(wall.center);
				if (dist <= wall.r * wall.r && !(wall.is_in(tarou) && wall.is_in(oni))) {
					auto nearest = measure.shift_to_point(wall.center).cross_point(view);
					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";
			}
		}
	}
}