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 <algorithm>
#include <string>
#include <math.h>
using namespace std;
#define EPS 1e-7
int n, m, wall[100][3], pp[4];
bool jud;
int main(){
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> wall[i][0] >> wall[i][1] >> wall[i][2];
	}
	cin >> m;
	for(int i = 0; i < m; i++){
		for(int j = 0; j < 4; j++){
			cin >> pp[j];
		}
		double dx = pp[0] - pp[2], dy = pp[1] - pp[3], kmk, spn;
		if(dx)
			kmk = dy / dx;
		else{
			for(int j = 0; j < n; j++){
				double a = 1, b = -2 * wall[j][1], c = (pp[0] - wall[j][0]) * (pp[0] - wall[j][0]) + wall[j][1] * wall[j][1] - wall[j][2] * wall[j][2];
				double D = b * b - 4 * a * c;
				if(D < -EPS){
					continue;
				}
				else if(D < 0){
					D = 0;
				}
				if(D >= 0){
					double aa = (sqrt(D) - b) / (2 * a);
					if(aa >= pp[1] && aa <= pp[3]){
						jud = 1;
						break;
					}
					if(aa >= pp[3] && aa <= pp[1]){
						jud = 1;
						break;
					}
					aa = (-sqrt(b * b - 4 * a * c) - b) / (2 * a);
				//	cout << aa << endl;
					if(aa >= pp[1] && aa <= pp[3]){
						jud = 1;
						break;
					}
					if(aa >= pp[3] && aa <= pp[1]){
						jud = 1;
						break;
					}
				} 
			}
			if(jud)
				cout << "Safe" << endl;
			else
				cout << "Danger" << endl;
			continue;
		}
		spn = -kmk * pp[0] + pp[1];
		jud = 0;
		for(int j = 0; j < n; j++){
			double a = 1 + kmk * kmk, b = -2 * wall[j][0] + 2 * kmk * spn - 2 * kmk * wall[j][1], c = wall[j][0] * wall[j][0] + wall[j][1] * wall[j][1] + spn * spn - 2 * spn * wall[j][1] - wall[j][2] * wall[j][2];
				double D = b * b - 4 * a * c;
				if(D < -EPS){
					continue;
				}
				else if(D < 0){
					D = 0;
				}
				if(D >= 0){
				double aa = (sqrt(D) - b) / (2 * a);
				if(aa >= pp[0] && aa <= pp[2]){
					jud = 1;
					break;
				}
				if(aa >= pp[2] && aa <= pp[0]){
					jud = 1;
						break;
				}
				aa = (-sqrt(b * b - 4 * a * c) - b) / (2 * a);
				if(aa >= pp[0] && aa <= pp[2]){
					jud = 1;
					break;
				}
				if(aa >= pp[2] && aa <= pp[0]){
					jud = 1;
					break;
				}
			}
		}
		if(jud)
			cout << "Safe" << endl;
		else
			cout << "Danger" << endl;
	}
}

C++: #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstring>
#include <sstream>
#include <cassert>
using namespace std;
static const double EPS = 1e-10;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PI;
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define F first
#define S second
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};

int wx[100],wy[100],r[100];

main(){
  int n;
  while(cin>>n,n){
    rep(i,n)cin>>wx[i]>>wy[i]>>r[i];

    int m;
    cin>>m;
    while(m--){
      int a,b,c,d;
      cin>>a>>b>>c>>d;
      bool safe=false;
      rep(i,n){
	if(a==c && b==d)break;
	int e=wx[i],f=wy[i],g=r[i];
	bool myin=(e-a)*(e-a)+(b-f)*(b-f)<g*g;
	bool enin=(e-c)*(e-c)+(f-d)*(f-d)<g*g;
	if(myin!=enin){
	  safe=true;
	  break;
	}
	if(myin && enin)continue;

	int varxy=(a*a-2*a*c+b*b-2*b*d+c*c+d*d);
	double xx=(a*a*e-a*b*d+a*b*f-2*a*c*e+a*d*d-a*d*f+b*b*c-b*c*d-b*c*f+c*c*e+c*d*f);
	xx=xx/varxy;
	double yy=(a*a*d-a*b*c+a*b*e-a*c*d-a*d*e+b*b*f+b*c*c-b*c*e-2*b*d*f+c*d*e+d*d*f);
	yy=yy/varxy;
	//cout<<xx<<' '<<yy<<endl;
	if((e-xx)*(e-xx)+(f-yy)*(f-yy)>g*g)continue;

	if((a<=xx && xx<=c) || (c<=xx && xx<=a)){
	  safe=true;
	  break;
	}

	continue;

	
	int var1=(-2*a*a*e+2*a*b*d-2*a*b*f+4*a*c*e-2*a*d*d+2*a*d*f-2*b*b*c+2*b*c*d+2*b*c*f-2*c*c*e-2*c*d*f);
	int var2=var1*var1-4*(a*a-2*a*c+b*b-2*b*d+c*c+d*d)*
	  (a*a*d*d-2*a*a*d*f+a*a*e*e+a*a*f*f-a*a*g*g-2*a*b*c*d+2*a*b*c*f+2*a*c*d*f
	   -2*a*c*e*e-2*a*c*f*f+2*a*c*g*g+b*b*c*c-2*b*c*c*f+c*c*e*e+c*c*f*f-c*c*g*g);
	if(var2<0)continue;
	int var3=2*a*a*e-2*a*b*d+2*a*b*f-4*a*c*e+2*a*d*d-2*a*d*f+2*b*b*c-2*b*c*d-2*b*c*f+
	  2*c*c*e+2*c*d*f;
	int var4=2*(a*a-2*a*c+b*b-2*b*d+c*c+d*d);
	double x1=double(sqrt(var2)+var3)/var4;
	double x2=double(-sqrt(var2)+var3)/var4;
	while(isnan(x1) || isnan(x2));
	if((a<=x1 && x1<=c) || (c<=x1 && x1<=a) || (a<=x2 && x2<=c) || (c<=x2 && x2<=a)){
	  safe=true;
	  break;
	}
      }
      if(safe)cout<<"Safe"<<endl;
      else cout<<"Danger"<<endl;
    }
  }
}

C++: #include<iostream>
#include<complex>

typedef std::complex<double> P;

const double EPS = 1e-10;

double dot( const P& a, const P& b )
{
	return std::real( std::conj( a ) * b );
}

double cross( const P& a, const P& b )
{
	return std::imag( std::conj( a ) * b );
}

// 線分abと点cの距離
double dist( const P& a, const P& b, const P& c )
{
	if( dot( b - a, c - a ) < EPS )
		return abs( c - a );
	if( dot( a - b, c - b ) < EPS )
		return abs( c - b );

	return abs( cross( b - a, c - a ) ) / abs( b - a );
}

int n;
P wpt[100];
double r[100];

std::istream& operator>> ( std::istream& in, P& p )
{
	if( in )
	{
		double x, y;
		in >> x >> y;
		p = P( x, y );
	}

	return in;
}

int main()
{
	while( std::cin >> n, n )
	{
		for( int i = 0; i != n; ++i )
			std::cin >> wpt[i] >> r[i];

		int m;
		std::cin >> m;
		for( int i = 0; i != m; ++i )
		{
			P s, t;
			std::cin >> s >> t;

			for( int j = 0; j != n; ++j )
			{
				if( !( abs( s - wpt[j] ) < r[j] && abs( t - wpt[j] ) < r[j] ) && dist( s, t, wpt[j] ) <= r[j] )
				{
					std::cout << "Safe" << std::endl;
					break;
				}
				else if( j == n - 1 )
					std::cout << "Danger" << std::endl;
			}
		}
	}

	return 0;
}