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() {
		if (den * num < 0) {
			abs();
			num *= -1;
		}
		auto g = gcd(std::abs(num), std::abs(den));
		num /= g; den /= g;
	}
	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 <algorithm>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <sstream>

#define rep(x,to) for(int x=0;x<to;x++)
#define rep2(x,from,to) for(int x=from;x<to;x++)
#define SQ(x) ((x)* (x))

using namespace std;

// 円と線分の当たり判定 http://r-force.seesaa.net/article/160353128.html //
bool jES(int sx1, int sy1, int sx2, int sy2, int x, int y, int r) {
    int d2;
    int a,b, c;
	
	a = sy2 - sy1;
	b = sx1 - sx2;
	c = -1 * (a * sx1 + b * sy1);  
	// d = abs(a*x+b*y+c)/sqrt(a*a+b*b)
	d2 = SQ(a*x+b*y+c);
	if(d2 > r*r * (a*a + b*b)) return false;
	
	if(((sx2-sx1)*(x-sx1)+(sy2-sy1)*(y-sy1)>0) &&
	   ((sx1-sx2)*(x-sx2)+(sy1-sy2)*(y-sy2)>0))  return true;
	
	return false;
}


int main(void){
 
int n, m;
int w[110][3];
int tx,ty,sx,sy;
	
	while(cin >> n){
		if(n==0 || cin.eof()) break;
		rep(i,n) cin >> w[i][0] >> w[i][1]>> w[i][2];
		
		cin >> m;
		rep(i,m){
			cin >> tx >> ty >> sx >> sy;
			bool ok = true;
			rep(j,n){
				if((SQ(tx-w[j][0]) + SQ(ty-w[j][1]) <= SQ(w[j][2])) &&
				   (SQ(sx-w[j][0]) + SQ(sy-w[j][1]) <= SQ(w[j][2]))) ok=false;
				else  ok = jES(tx,ty,sx,sy,w[j][0],w[j][1],w[j][2]);
		//		cout << "test:::" <<(ok?  "Safe": "Danger") << endl;
				if(ok) break;
			}
			cout << (ok? "Safe": "Danger") << endl;
		}
	}
}