#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cmath>
#include <bitset>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;

struct Point{
    double x,y,z;
    Point(double x, double y, double z):x(x), y(y), z(z){}
    Point(){}
    Point &operator +=(const Point &a){ x+=a.x; y+=a.y; z+=a.z; return *this; }
    Point &operator -=(const Point &a){ x-=a.x; y-=a.y; z-=a.z; return *this; }
    Point &operator *=(const double &a){ x*=a; y*=a; z*=a; return *this; }
    Point operator +(const Point &a) const{ return Point(x+a.x, y+a.y, z+a.z); }
    Point operator -(const Point &a) const{ return Point(x-a.x, y-a.y, z-a.z); }
    Point operator *(const double &a) const{ return Point(a*x, a*y, a*z); }
    Point operator -() { return Point(-x, -y, -z); }
};
double dot(const Point &a, const Point &b){
    return a.x*b.x +a.y*b.y +a.z*b.z;
}
Point cross(const Point &a, const Point &b){
    return Point(a.y*b.z -a.z*b.y, a.z*b.x -a.x*b.z, a.x*b.y -a.y*b.x);
}
double abs(const Point &a){
    return sqrt(dot(a, a));
}
Point unit(const Point &a){
    return a *(1/abs(a));
}
bool operator ==(const Point &a, const Point &b){
    return abs(a-b) < EPS;
}

Point projectionSP3(Point p, Point q, Point c){
    double t = dot(unit(q-p), c-p);
    return p +unit(q-p) *t;
}
Point reflectionSP3(Point p, Point q, Point c){
    Point proj = projectionSP3(p, q, c);
    return proj*2 -c;
}
double distanceSP3(Point p, Point q, Point c){
    Point r = projectionSP3(p, q, c);
    if(dot(q-p, r-p) < 0) return abs(c-p);
    if(dot(p-q, r-q) < 0) return abs(c-q);
    return abs(c-r);
}
Point crossopintLP3FS(Point p, Point q, Point c, double r){
    Point s = projectionSP3(p, q, c);
    double t = sqrt(r*r -abs(c-s)*abs(c-s));
    Point ret[2] = {s +unit(p-q)*t, s -unit(p-q)*t};
    return (abs(ret[0]-p) < abs(ret[1]-p))? ret[0]: ret[1];
}

int main(){
    while(1){
        int n;
        cin >> n;
        if(n==0) break;

        Point pos(0,0,0), dir;
        cin >> dir.x >> dir.y >> dir.z;
        vector<Point> p(n);
        vector<double> r(n);
        for(int i=0; i<n; i++){
            cin >> p[i].x >> p[i].y >> p[i].z >> r[i];
        }

        while(1){
            bool touch = false;
            Point npos(INF, INF, INF), ndir;
            Point ep = pos +unit(dir)*1e4;
            for(int i=0; i<n; i++){
                if(distanceSP3(pos, ep, p[i]) +EPS < r[i]){
                    Point ref = crossopintLP3FS(pos, ep, p[i], r[i]);
                    if(ref == pos) continue;
                    if(abs(pos -ref) > abs(pos -npos)) continue;
                    Point to = reflectionSP3(p[i], ref, pos);
                    npos = ref;
                    ndir = to -ref;
                    touch = true;
                }
            }
            if(!touch){
                break;
            }
            pos = npos;
            dir = ndir;
        }
        cout << fixed << setprecision(4);
        cout << pos.x << " " << pos.y << " " << pos.z << endl;
    }
    return 0;
}
