#include <bitset>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;

template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }

struct point {
	int x, y, z;

	point(int x_, int y_, int z_):x(x_), y(y_), z(z_) {}
	point(const point &p):x(p.x), y(p.y), z(p.z) {}

	point operator-(const point &p) const {
		return point(x - p.x, y - p.y, z - p.z);
	}
};

struct segment {
	point a, b;

	segment(const point &a_, const point &b_):a(a_), b(b_) {}
	segment(const segment &s):a(s.a), b(s.b) {}
};

struct circle {
	point c;
	int r;

	circle(const point &c_, int r_):c(c_), r(r_) {}
	circle(const circle &c_):c(c_.c), r(c_.r) {}
};

int dot(const point &a, const point &b) {
	return a.x * b.x + a.y * b.y + a.z * b.z;
}

int norm(const point &p) {
	return p.x * p.x + p.y * p.y + p.z * p.z;
}

int dist2(const point &a, const point &b) {
	return norm(a - b);
}

double dist2(const segment &s, const point &p) {
	const int a = dot(s.b - s.a, s.b - s.a);
	const int b = dot(s.b - s.a, s.a - p);
	const int c = dot(s.a - p, s.a - p);
	const double t = -1.0 * b / a;
	if(t < 0) return dist2(s.a, p);
	if(t > 1) return dist2(s.b, p);
	return a * t * t + 2 * b * t + c;
}

bool intersect(const circle &c, const point &p) {
	return dist2(c.c, p) <= c.r * c.r;
}

bool intersect(const circle &c, const segment &s) {
	return dist2(s, c.c) <= c.r * c.r;
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	cout.flags(ios::fixed);
	cout.precision(5);

	for(int N, M, R; cin >> N >> M >> R && N;) {
		vector<circle> baloons;
		baloons.reserve(N);
		for(int i = 0; i < N; ++i) {
			int x, y, z, r;
			cin >> x >> y >> z >> r;
			baloons.emplace_back(point(x, y, z), r);
		}

		vector<point> sources;
		vector<int> tb(M);
		sources.reserve(M);
		for(int i = 0; i < M; ++i) {
			int x, y, z;
			cin >> x >> y >> z >> tb[i];
			sources.emplace_back(x, y, z);
		}

		int x, y, z;
		cin >> x >> y >> z;
		point e(x, y, z);

		vector<double> intensity(M);
		for(int i = 0; i < M; ++i) {
			intensity[i] = (double)tb[i] / dist2(e, sources[i]);
		}

		vector<bitset<2000>> removed(M);
		for(int i = 0; i < M; ++i) {
			const segment seg(e, sources[i]);
			for(int j = 0; j < N; ++j) {
				if(intersect(baloons[j], seg) && !(intersect(baloons[j], seg.a) && intersect(baloons[j], seg.b))) {
					removed[i].set(j);
				}
			}
		}

		double ans = 0.0;
		for(int i = 0; i < (1 << M); ++i) {
			double sum = 0.0;
			bitset<2000> bit;
			
			for(int j = 0; j < M; ++j) {
				if(i & (1 << j)) {
					bit |= removed[j];
					sum += intensity[j];
				}
			}

			if(static_cast<int>(bit.count()) <= R) chmax(ans, sum);
		}

		cout << ans << endl;
	}

	return EXIT_SUCCESS;
}