Problem: Suppose that there are some light sources and many spherical balloons. All light sources have sizes small enough to be modeled as point light sources, and they emit light in all directions. The surfaces of the balloons absorb light and do not reflect light. Surprisingly in this world, balloons may overlap.

You want the total illumination intensity at an objective point as high as possible. For this purpose, some of the balloons obstructing lights can be removed. Because of the removal costs, however, there is a certain limit on the number of balloons to be removed. Thus, you would like to remove an appropriate set of balloons so as to maximize the illumination intensity at the objective point.

The following figure illustrates the configuration specified in the first dataset of the sample input given below. The figure shows the xy-plane, which is enough because, in this dataset, the z-coordinates of all the light sources, balloon centers, and the objective point are zero. In the figure, light sources are shown as stars and balloons as circles. The objective point is at the origin, and you may remove up to 4 balloons. In this case, the dashed circles in the figure correspond to the balloons to be removed.

<image>

Figure G.1: First dataset of the sample input.



Input

The input is a sequence of datasets. Each dataset is formatted as follows.

N M R
S1x S1y S1z S1r
...
SNx SNy SNz SNr
T1x T1y T1z T1b
...
TMx TMy TMz TMb
Ex Ey Ez


The first line of a dataset contains three positive integers, N, M and R, separated by a single space. N means the number of balloons that does not exceed 2000. M means the number of light sources that does not exceed 15. R means the number of balloons that may be removed, which does not exceed N.

Each of the N lines following the first line contains four integers separated by a single space. (Six, Siy, Siz) means the center position of the i-th balloon and Sir means its radius.

Each of the following M lines contains four integers separated by a single space. (Tjx, Tjy, Tjz) means the position of the j-th light source and Tjb means its brightness.

The last line of a dataset contains three integers separated by a single space. (Ex, Ey, Ez) means the position of the objective point.

Six, Siy, Siz, Tjx, Tjy, Tjz, Ex, Ey and Ez are greater than -500, and less than 500. Sir is greater than 0, and less than 500. Tjb is greater than 0, and less than 80000.

At the objective point, the intensity of the light from the j-th light source is in inverse proportion to the square of the distance, namely

Tjb / { (Tjx − Ex)2 + (Tjy − Ey)2 + (Tjz − Ez)2 },

if there is no balloon interrupting the light. The total illumination intensity is the sum of the above.

You may assume the following.

1. The distance between the objective point and any light source is not less than 1.
2. For every i and j, even if Sir changes by ε (|ε| < 0.01), whether the i-th balloon hides the j-th light or not does not change.


The end of the input is indicated by a line of three zeros.

Output

For each dataset, output a line containing a decimal fraction which means the highest possible illumination intensity at the objective point after removing R balloons. The output should not contain an error greater than 0.0001.

Example

Input

12 5 4
0 10 0 1
1 5 0 2
1 4 0 2
0 0 0 2
10 0 0 1
3 -1 0 2
5 -1 0 2
10 10 0 15
0 -10 0 1
10 -10 0 1
-10 -10 0 1
10 10 0 1
0 10 0 240
10 0 0 200
10 -2 0 52
-10 0 0 100
1 1 0 2
0 0 0
12 5 4
0 10 0 1
1 5 0 2
1 4 0 2
0 0 0 2
10 0 0 1
3 -1 0 2
5 -1 0 2
10 10 0 15
0 -10 0 1
10 -10 0 1
-10 -10 0 1
10 10 0 1
0 10 0 260
10 0 0 200
10 -2 0 52
-10 0 0 100
1 1 0 2
0 0 0
5 1 3
1 2 0 2
-1 8 -1 8
-2 -3 5 6
-2 1 3 3
-4 2 3 5
1 1 2 7
0 0 0
5 1 2
1 2 0 2
-1 8 -1 8
-2 -3 5 6
-2 1 3 3
-4 2 3 5
1 1 2 7
0 0 0
0 0 0


Output

3.5
3.6
1.1666666666666667
0.0

Solution (in CPP):

Solution:
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

enum Type{
	UNKNOWN,
	YES,
	NO,
};

//3次元
struct Point{
	Point(double arg_x,double arg_y,double arg_z){
		x = arg_x;
		y = arg_y;
		z = arg_z;
	}

	Point(){
		x = y = z = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y,z+p.z); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y,z-p.z);}
	Point operator * (double a){ return Point(a*x,a*y,a*z); }
	Point operator / (double a){ return Point(x/a,y/a,z/a); }

	double abs(){ return sqrt(norm()); }
	double norm(){ return x*x + y*y + z*z; }

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS && fabs(z-p.z) < EPS;
	}
	double x,y,z;
};

typedef Point Vector;

struct Line{
	Line(Point a,Point b){
		p[0] = a;
		p[1] = b;
	}
	Point p[2];
};

struct Sphere{
	Point center;
	double r;
};

struct Data{
	Point center;
	double value;
};

int N,M,R;
int POW[16];
Sphere balloon[2000];
Data light[15];
Point E;
double memo[15][2000],dist_BalloonObject[2000],distLightBalloon[15][2000];
bool check[2000];

//3次元
double norm(Vector a){
	return a.x*a.x+a.y*a.y+a.z*a.z;
}

double abs(Vector a){
	return sqrt(norm(a));
}

double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y+a.z*b.z;
}

double calc_value(int index){
	return light[index].value/((light[index].center.x-E.x)*(light[index].center.x-E.x)
			+(light[index].center.y-E.y)*(light[index].center.y-E.y)
			+(light[index].center.z-E.z)*(light[index].center.z-E.z));
}

//垂線が引ける場合、交点を求める
Point projection(Line line,Point point){
    double t = dot(point-line.p[0],line.p[0]-line.p[1])/norm(line.p[0]-line.p[1]);
    return line.p[0] + (line.p[0]-line.p[1])*t;
}

double calc_dist(Point a,Point b){
	return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z));
}

bool intersect(int light_index,int balloon_index){

	if(memo[light_index][balloon_index] != UNKNOWN)return memo[light_index][balloon_index] == YES;

	//balloonの中心と観測点の距離
	double dist_1 = dist_BalloonObject[balloon_index];
	double dist_2 = distLightBalloon[light_index][balloon_index];

	if(dist_1 <= balloon[balloon_index].r && dist_2 <= balloon[balloon_index].r){
		memo[light_index][balloon_index] = NO;  //観測点と光源がballoonの内部にあるなら妨害なし
		return false;
	}

	//方向ベクトル
	double Vx = light[light_index].center.x-E.x;
	double Vy = light[light_index].center.y-E.y;
	double Vz = light[light_index].center.z-E.z;

	//Oを原点,点Aを観測点としたとき、点balloon_indexから下した垂線との交点が、(E_x+t*Vx,E_y+t*Vy,E_z+t*Vz)と表されるようなt
	double t = (Vx*(balloon[balloon_index].center.x-E.x)+Vy*(balloon[balloon_index].center.y-E.y)+Vz*(balloon[balloon_index].center.z-E.z))/(Vx*Vx+Vy*Vy+Vz*Vz);

	if(t < 0 || t > 1){ //垂線が、観測点と光源を結ぶ線分上にない場合→最近地点は、観測点か光源のどちらか
		if(dist_1 > balloon[balloon_index].r && dist_2 > balloon[balloon_index].r){
			memo[light_index][balloon_index] = NO;
			return false;
		}else{
			memo[light_index][balloon_index] = YES;
			return true;
		}
	}

	double cross_x = E.x+t*Vx;
	double cross_y = E.y+t*Vy;
	double cross_z = E.z+t*Vz;

	double dist = sqrt((balloon[balloon_index].center.x-cross_x)*(balloon[balloon_index].center.x-cross_x)
			+(balloon[balloon_index].center.y-cross_y)*(balloon[balloon_index].center.y-cross_y)
			+(balloon[balloon_index].center.z-cross_z)*(balloon[balloon_index].center.z-cross_z)
		);

	if(dist <= balloon[balloon_index].r){
		memo[light_index][balloon_index] = YES;
		return true;
	}else{
		memo[light_index][balloon_index] = NO;
		return false;
	}
}

void func(){

	for(int i = 0; i < M; i++){
		for(int k = 0; k < N; k++)memo[i][k] = UNKNOWN;
	}

	for(int i = 0; i < N; i++){
		scanf("%lf %lf %lf %lf",&balloon[i].center.x,&balloon[i].center.y,&balloon[i].center.z,&balloon[i].r);
	}
	for(int i = 0; i < M; i++){
		scanf("%lf %lf %lf %lf",&light[i].center.x,&light[i].center.y,&light[i].center.z,&light[i].value);
	}
	scanf("%lf %lf %lf",&E.x,&E.y,&E.z);

	//balloonの中心と観測地点との距離を計算
	for(int i = 0; i < N; i++){
		dist_BalloonObject[i] = calc_dist(balloon[i].center,E);
	}
	//光源とballoonの中心との距離を計算
	for(int i = 0; i < M; i++){
		for(int k = 0; k < N; k++){
			distLightBalloon[i][k] = calc_dist(light[i].center,balloon[k].center);
		}
	}

	double ans = 0.0,tmp_sum;
	int break_num;

	for(int state = POW[M]; state > 0; state--){ //光を拾う光源の組み合わせを調べる
		break_num = 0;
		tmp_sum = 0.0;
		for(int loop = 0; loop < M; loop++){
			if(state & (1 << loop)){
				tmp_sum += calc_value(loop);
			}
		}
		if(tmp_sum <= ans)continue; //ansより小さいならSKIP

		tmp_sum = 0.0;
		for(int i = 0; i < N; i++)check[i] = false; //割れたらtrue
		for(int loop = 0; loop < M; loop++){
			if(state & (1 << loop)){ //光源loopの光を拾う場合
				tmp_sum += calc_value(loop);
				//交差する（割る）バルーンの数を数える
				for(int i = 0; i < N; i++){
					if(check[i] == false && intersect(loop,i) == true){
						break_num++;
						check[i] = true;
					}
				}

				if(break_num > R)break;
			}
		}
		if(break_num <= R){
			ans = max(ans,tmp_sum);
		}
	}
	printf("%.10lf\n",ans);
}

int main(){

	for(int i = 0; i < 16; i++)POW[i] = pow(2,i);

	while(true){
		scanf("%d %d %d",&N,&M,&R);
		if(N == 0 && M == 0 && R == 0)break;

		func();
	}

	return 0;
}