#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <cassert>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
#include <iomanip>
#include <fstream>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<b?(a=b,1):0)
#define chmin(a,b) (a>b?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
const int INF = 1<<29;
const double EPS = 1e-8;
typedef long long ll;
typedef pair<int,int> pii;

typedef valarray<double> point;
struct line : public vector<point> {
  line() {}
  line(point a, point b) { push_back(a); push_back(b); }
};
point Point(double x, double y, double z) {
  point p(3);
  p[0]=x;p[1]=y;p[2]=z;
  return p;
}
double dot(const point& a, const point& b) {
  return (a * b).sum();
}
point cross(const point& a, const point& b) {
  return a.cshift(+1)*b.cshift(-1)
       - a.cshift(-1)*b.cshift(+1);
}
double norm(const point &a) {
  return dot(a,a);
}
double length(const point &a) {
  return sqrt(dot(a,a));
}
double angle(const point &a, const point &b) {
  return acos( dot(a,b)/length(a)/length(b) );
}
point input() {
  double a[3];
  REP(i,3) cin >>a[i];
  return point(a,3);
}
ostream &operator<<(ostream &os, const point &a) {
  char str[200];
  snprintf(str, 199, "(%.2f, %.2f, %.2f)", a[0], a[1], a[2]);
  os << str;
  return os;
}

point projection(const line &l, const point &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t * (l[0]-l[1]);
}
bool intersectSP(const line &s, const point &p) {
  return length(s[0]-p) + length(s[1]-p) - length(s[1]-s[0]) < EPS;
}
double distanceSP(const line &s, const point &p) {
  const point r = projection(s, p);
  if (intersectSP(s, r)) { return length(r-p); }
  return min(length(s[0]-p), length(s[1]-p));
}

bool judge(const point &e, const point &light, const point &balloon, double r) {
  if (norm(e-balloon) <= r*r && norm(light-balloon) <= r*r) return 0;
  if (distanceSP(line(light,e), balloon) <= r) return 1;
  return 0;
}

int main() {
  int n,m,R;
  while(cin>>n>>m>>R,n||m||R) {
    vector<point> balloon;
    vector<double> balR;
    REP(i,n) {
      balloon.push_back(input());
      double r; cin >> r;
      balR.push_back(r);
    }
    vector<point> light;
    vector<double> brightness;
    REP(i,m) {
      light.push_back(input());
      double b; cin >> b;
      brightness.push_back(b);
    }
    point e(input());
    bitset<2000> bit[15];
    double B[m];
    REP(i,m) {
      REP(j,n) {
        if (judge(e,light[i],balloon[j],balR[j])) bit[i][j] = 1;
      }
      B[i] = brightness[i] / norm(e-light[i]);
    }
    // REP(i,m) {
    //   REP(j,n) cout << bit[i][j];
    //   cout << endl;
    // }
    double ans = 0;
    REP(S,1<<m) {
      if (S == 0) continue;
      bitset<2000> tmp;
      double sum = 0;
      REP(i,m) {
        if (S>>i&1) {
          tmp |= bit[i];
          sum += B[i];
        }
      }
      if (tmp.count() <= R) {
        chmax(ans, sum);
      }
    }
    printf("%.10f\n", ans);
  }
}

Measured memory_bytes: 1412