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<stdio.h>
#include<algorithm>
using namespace std;
int x[100];
int y[100];
int r[100];
int main(){
    int a;
    while(scanf("%d",&a),a){
        for(int i=0;i<a;i++)scanf("%d%d%d",x+i,y+i,r+i);
        int b;
        scanf("%d",&b);
        for(int i=0;i<b;i++){
            int c,d,e,f;
            scanf("%d%d%d%d",&c,&d,&e,&f);
            bool ok=false;
            for(int 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)printf("Safe\n");
            else printf("Danger\n");
        }
    }
}

C++: #include <iostream>
#include <cmath>
#include <string.h>
using namespace std;

struct Circle{
	int x;
	int y;
	int r;
};

struct Segment{
	int sx;
	int sy;
	int ex;
	int ey;
};

class Vector2{
public:
	Vector2( const int _x, const int _y ) : x( _x ), y( _y ){}
	int x;
	int y;

	int dotProduct( const Vector2& v )
	{
		return x * v.x + y * v.y;
	}
	int clossProduct( const Vector2& v )
	{
		return x * v.y - y * v.x;
	}
	double length()
	{
		return sqrt( static_cast<double>( x * x + y * y ) );
	}
};

int main()
{
	int n, m;
	while( cin >> n ){
		if( n == 0 ){
			break;
		}
		Circle* circles = new Circle[ n ];
		for( int i = 0; i < n; ++i ){
			cin >> circles[ i ].x >> circles[ i ].y >> circles[ i ].r;
		}

		cin >> m;
		if( m == 0 ){
			delete[] circles;
			continue;
		}
		Segment seg;
		for( int i = 0; i < m; ++i ){
			cin >> seg.sx >>seg.sy >> seg.ex >> seg.ey;
			bool safety = false;

			for( int j = 0 ; j < n; ++j ){
				Circle* cir = &circles[ j ];
				bool collision = false;

				Vector2 se( seg.ex - seg.sx, seg.ey - seg.sy );
				Vector2 sc( cir->x - seg.sx, cir->y - seg.sy );
				Vector2 ec( cir->x - seg.ex, cir->y - seg.ey );
				double d = se.clossProduct( sc ) / se.length();
				if( !( sc.length() < static_cast<double>( cir->r )
					&& ec.length() < static_cast<double>( cir->r ) ) ){
					if( d <= static_cast<double>( cir->r ) ){
						if( sc.dotProduct( se ) * ec.dotProduct( se ) <= 0 ){
							collision = true;
						}else if( sc.length() < static_cast<double>( cir->r )
							|| ec.length() < static_cast<double>( cir->r ) ){
							collision = true;
						}
					}
				}
				if( collision ){
					safety = true;
					break;
				}
			}
			cout << ( safety ? "Safe" : "Danger" ) << endl;
		}
		delete[] circles;
	}
	return 0;
}

C++: #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 <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>

#if __cplusplus >= 201103L
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>

#define cauto const auto&
#else

#endif

using namespace std;


namespace{
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#define double long double
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()


#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;

int check(double x1,double y1,double x2,double y2,double r2){
	double xy=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1),r=r2*r2;
	if(r-xy<-EPS) return 1;
	else return -1;
}


void mainmain(){
	int n;
	while(cin>>n,n){
		vector<pair<pair<double,double>,double > >  a(n);
		rep(i,n){
			cin>>a[i].F.F>>a[i].F.S>>a[i].S;
		}
		int m;
		cin>>m;
		// vector<pair<double,double> > b(m);
		rep(l,m){
			double b[4];
			cin>>b[0]>>b[1]>>b[2]>>b[3];
			bool f=false;
			double x=b[0],y=b[1];
			double dx=(b[2]-b[0])/10000.0,dy=(b[3]-b[1])/10000.0;
			rep(i,n){
				int t=check(b[0],b[1],a[i].F.F,a[i].F.S,a[i].S);
				reep(j,1,10001){
					int t1=check(x+dx*j,y+dy*j,a[i].F.F,a[i].F.S,a[i].S);
						// cout<<x+dx*j<<" "<<y+dy*j<<" "<<a[i].F.F<<" "<<a[i].F.S<<" "<<a[i].S<<endl;
					if(t!=t1){
						f=true;
						break;
					}	
				}
				if(f) break;
			}
			if(f) cout<<"Safe\n";
			else cout<<"Danger\n";
		}
	}
	// cout<<check(0,3,3,3,3)<<endl;
	// cout<<check(-1,3,3,3,3)<<endl;
	// cout<<check(0.5,0,1,0,1)<<endl;
}



}
main() try{
    mainmain();
}
catch(...){
}