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 <cmath>
#include <vector>

class Rational {
	using N = long long 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";
			}
		}
	}
}

C++: #include<iostream>
#include<complex>
#include<algorithm>
#include<vector>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
using namespace std;
typedef complex<double> P;
typedef pair<double,double> point;


double dot(P a,P b){
	return real(conj(a)*b);
}

double cross(P a,P b){
	return imag(conj(a)*b);
}

double dist(P a, P b,P c){
	if(dot(b-a,c-a)<0)return abs(c-a);
	if(dot(a-b,c-b)<0)return abs(c-b);
	return abs(cross(c-a,b-a))/abs(b-a);
}

int main(){
	int n,m;
	double x,y,r;
	P taro,oni;
	vector<pair<P,double> > circle; 
	while(cin>>n,n){
		circle.clear();
		rep(i,n){
			cin>>x>>y>>r;
			circle.pb(pair<P,double>(P(x,y),r));
		}
		cin>>m;
		rep(p,m){
			cin>>x>>y;
			taro=P(x,y);
			cin>>x>>y;
			oni=P(x,y);
			bool check=false;
			rep(i,n){
				r=circle[i].second;
				double d=dist(taro,oni,circle[i].first);
				if(d<=r && (abs(taro-circle[i].first)>=r || abs(oni-circle[i].first)>=r)){
					check=true;
					break;
				}
			}
			if(check)cout<<"Safe"<<endl;
			else cout<<"Danger"<<endl;
		}
	}
	return 0;
}