#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>

using namespace std;
static const double EPS = 1e-8;
inline int sign(double x){ return abs(x) < EPS ? 0 : (x > 0 ? 1 : -1); }

struct Point3D {
	double x, y, z;
	Point3D() : x(0), y(0), z(0) { }
	Point3D(double x, double y, double z) : x(x), y(y), z(z) { }

	Point3D operator-() const { return Point3D(-x, -y, -z); }
	Point3D operator+(const Point3D &p) const {
		return Point3D(x + p.x, y + p.y, z + p.z);
	}
	Point3D operator-(const Point3D &p) const {
		return Point3D(x - p.x, y - p.y, z - p.z);
	}
	Point3D operator*(const double s) const {
		return Point3D(x * s, y * s, z * s);
	}
	Point3D operator/(const double s) const {
		return Point3D(x / s, y / s, z / s);
	}
};

struct Line3D {
	Point3D a, b;
	Line3D() : a(), b() { }
	Line3D(const Point3D &a, const Point3D &b) : a(a), b(b) { }
};

struct Sphere {
	Point3D c;
	double r;
	Sphere() : c(), r(0) { }
	Sphere(const Point3D &c, double r) : c(c), r(r) { }
};

inline double dot(const Point3D &a, const Point3D &b){
	return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline Point3D cross(const Point3D &a, const Point3D &b){
	return Point3D(
		a.y * b.z - a.z * b.y,
		a.z * b.x - a.x * b.z,
		a.x * b.y - a.y * b.x);
}
inline double norm(const Point3D &p){
	return p.x * p.x + p.y * p.y + p.z * p.z;
}
inline double abs(const Point3D &p){
	return sqrt(norm(p));
}
inline Point3D unit(const Point3D &p){
	return p / abs(p);
}
inline Point3D vec(const Line3D &l){
	return l.b - l.a;
}

inline Point3D projection(const Line3D &l, const Point3D &p){
	const Point3D v = vec(l);
	return l.a + v * (dot(p - l.a, v) / norm(v));
}
inline Point3D reflection(const Line3D &l, const Point3D &p){
	const Point3D q = projection(l, p);
	return q + q - p;
}

inline bool intersectLP(const Line3D &l, const Point3D &p){
	return !sign(norm(cross(p - l.a, vec(l))));
}
inline bool intersectSP(const Line3D &l, const Point3D &p){
	const Point3D a = p - l.a, b = vec(l);
	if(norm(a) < EPS || norm(a - b) < EPS){ return true; }
	if(norm(cross(a, b)) > EPS){ return false; }
	if(sign(a.x * b.x) < 0){ return false; }
	if(sign(a.y * b.y) < 0){ return false; }
	if(sign(a.z * b.z) < 0){ return false; }
	return norm(a) < norm(b);
}
inline double distanceLP(const Line3D &l, const Point3D &p){
	const Point3D q = projection(l, p);
	return abs(p - q);
}
inline double distanceSP(const Line3D &l, const Point3D &p){
	const Point3D u = p - l.a;
	const Point3D v = projection(Line3D(Point3D(), vec(l)), u);
	if(intersectSP(Line3D(Point3D(), vec(l)), v)){ return abs(u - v); }
	return sqrt(min(norm(p - l.a), norm(p - l.b)));
}

vector<Point3D> crosspointCL(const Sphere &s, const Line3D &l){
	const Point3D &p = projection(l, s.c);
	const double d2 = norm(s.c - p);
	if(d2 > s.r * s.r + EPS){ return vector<Point3D>(); }
	if(d2 > s.r * s.r - EPS){ return vector<Point3D>(1, p); }
	const double sc = sqrt(s.r * s.r - d2);
	vector<Point3D> ret;
	ret.push_back(p + unit(vec(l)) * sc);
	ret.push_back(p - unit(vec(l)) * sc);
	return ret;
}
vector<Point3D> crosspointCS(const Sphere &s, const Line3D &l){
	const vector<Point3D> ps = crosspointCL(s, l);
	vector<Point3D> ret;
	for(int i = 0; i < ps.size(); ++i){
		if(intersectSP(l, ps[i])){ ret.push_back(ps[i]); }
	}
	return ret;
}

bool intersectCL(const Sphere &s, const Line3D &l){
	return distanceLP(l, s.c) < s.r + EPS;
}
bool intersectCS(const Sphere &s, const Line3D &l){
	return !crosspointCS(s, l).empty();
}

int main(){
	ios_base::sync_with_stdio(false);
	cout << setiosflags(ios::fixed) << setprecision(10);
	const double length = 1000.0;
	while(true){
		int n;
		cin >> n;
		if(n == 0){ break; }
		Point3D init;
		cin >> init.x >> init.y >> init.z;
		vector<Sphere> spheres(n);
		for(int i = 0; i < n; ++i){
			double x, y, z, r;
			cin >> x >> y >> z >> r;
			spheres[i] = Sphere(Point3D(x, y, z), r);
		}
		Line3D cur(Point3D(), unit(init) * length);
		Point3D answer;
		while(true){
			double best_length = length;
			Line3D next;
			for(int i = 0; i < n; ++i){
				if(abs(abs(spheres[i].c - cur.a) - spheres[i].r) < EPS){
					continue;
				}
				const vector<Point3D> ps = crosspointCS(spheres[i], cur);
				if(ps.empty()){ continue; }
				double l = length;
				int key = 0;
				for(int j = 0; j < ps.size(); ++j){
					const double t = abs(ps[j] - cur.a);
					if(t >= l){ continue; }
					l = t;
					key = j;
				}
				if(l >= best_length){ continue; }
				best_length = l;
				answer = ps[key];
				const Point3D r =
					reflection(Line3D(spheres[i].c, answer), cur.a);
				next = Line3D(answer, answer + unit(r - answer) * length);
			}
			if(best_length >= length){ break; }
			cur = next;
		}
		cout << answer.x << " " << answer.y << " " << answer.z << endl;
	}
	return 0;
}

Measured memory_bytes: 1312