#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <cassert>
#include <bitset>
#include <string>
#include <memory.h>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <cctype>
#include <fstream>
#include <complex>
#include <cmath>
using namespace std;

#define REP2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for(ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n) & 1)

typedef long long ll;
typedef pair<ll, ll> P;
typedef complex<double> xy_t;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;


struct Point{
  double x, y, z;
  Point(double x, double y, double z) : x(x), y(y), z(z) {}
  Point(){}
  friend istream &operator>>(istream &in, Point &p){
    in >> p.x >> p.y >> p.z;
    return in;
  }
  friend ostream &operator<<(ostream &out, const Point &p){
    out << "(" << p.x << ", " << p.y << ", " << p.z << ")";
    return out;
  }

  friend Point operator+(const Point &p, const Point &q){
    Point r(p);
    r.x += q.x;
    r.y += q.y;
    r.z += q.z;
    return r;
  }
  
  friend Point operator-(const Point &p, const Point &q){
    Point r(p);
    r.x -= q.x;
    r.y -= q.y;
    r.z -= q.z;
    return r;
  }

  friend Point operator*(double scale, const Point &p){
    Point r(p);
    r.x *= scale;
    r.y *= scale;
    r.z *= scale;
    return r;
  }
};


double dot(const Point &p1, const Point &p2){
  return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;
}

double dist2(const Point &p1, const Point &p2){
  double dx = p1.x - p2.x;
  double dy = p1.y - p2.y;
  double dz = p1.z - p2.z;
  return dx * dx + dy * dy + dz * dz;
}

double dist(const Point &p1, const Point &p2){
  return sqrt(dist2(p1, p2));
}

struct Sphere{
  Point p;
  double r;
  
  Sphere(double x, double y, double z, double r) :
    p(x, y, z), r(r){}
  Sphere(){}
  friend istream &operator>>(istream &in, Sphere &s){
    in >> s.p >> s.r;
    return in;
  }
  friend ostream &operator<<(ostream &out, const Sphere &s){
    out << "(" << s.p.x << ", " << s.p.y
	<< ", "<< s.p.z << ", " << s.
r << ")";
    return out;
  }

  bool inside(const Point &q){
    return dist2(p, q) < r * r + EPS;
  }
};


struct L{
  Point f, t;
  L(){}
  L(const Point &f, const Point &t) : f(f), t(t) {}
};

Point projection(const L &l, const Point &p){
  double t = dot(p - l.f, l.f - l.t) / dist2(l.f, l.t);
  return l.f + t * (l.f - l.t);
}

double intersectSP(const L &l, const Point &p){
  return dist(l.f, p) + dist(p, l.t) < dist(l.f, l.t) + EPS;
}

double distanceSP(const L &l, const Point &p){
  const Point r = projection(l,p);
  if(intersectSP(l, r)) return dist(r, p);
  return min(dist(l.f, p), dist(l.t, p));
}

const int MAXN = 3000;

int main(){
  int N, M, R;
  while(cin >> N >> M >> R && N + M + R){
    vector<Sphere> balloons(N);
    vector<Point>  light(M);
    vector<double> power(M);
    vector<bitset<MAXN> > obstacle(M);
    Point object;
    
    REP(i, N) cin >> balloons[i];
    REP(i, M) cin >> light[i] >> power[i];
    cin >> object;
    
    REP(i, M){
      REP(j, N){
	bool f1 = balloons[j].inside(light[i]);
	bool f2 = balloons[j].inside(object);
	double d = distanceSP(L(object,light[i]),balloons[j].p);
	if((!f1 || !f2) && d < balloons[j].r){
	  obstacle[i][j] = 1;
	}
      }

    }

    double ans = 0;
    REP(mask, 1 << M){
      bitset<MAXN> obs;
      REP(i, M)if(PARITY(mask >> i) == 1){
	obs |= obstacle[i];
      }
      
      if((int)obs.count() <= R){
	double sum = 0;
	  
	REP(i, M)if(PARITY(mask >> i)){
	  sum += power[i] / dist2(light[i], object);
	}
	ans = max(ans, sum);
      }
    }
    printf("%.20lf\n", ans);
  }
  return 0;
}

Measured memory_bytes: 1324