#include <cassert>// c
#include <ctime>
#include <iostream>// io
#include <iomanip>
#include <fstream>
#include <sstream>
#include <vector>// container
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <stack>
#include <algorithm>// other
#include <complex>
#include <numeric>
#include <functional>
#include <random>
#include <regex>
#include <valarray>

using namespace std;
typedef long long ll;

#define ALL(c) (c).begin(),(c).end()
#define FOR(i,l,r) for(int i=(int)l;i<(int)r;++i)
#define REP(i,n) FOR(i,0,n)
#define FORr(i,l,r) for(int i=(int)r-1;i>=(int)l;--i)
#define REPr(i,n) FORr(i,0,n)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define IN(l,v,r) ((l)<=(v) && (v)<(r))
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end())
//debug
#define DUMP(x)  cerr << #x << " = " << (x)
#define LINE()    cerr<< " (L" << __LINE__ << ")"

template<typename T,typename U> T pmod(T x,U M){return (x%M+M)%M;}

// must template
typedef double D;
const D INF = 1e12,EPS = 1e-8;

typedef complex<D> P;
#define X real()
#define Y imag()
istream& operator >> (istream& is,P& p){D x,y;is >> x >> y; p=P(x,y); return is;}

int sig(D a,D b=0){return a<b-EPS?-1:a>b+EPS?1:0;}
template<typename T> bool eq(const T& a,const T& b){return sig(abs(a-b))==0;}
bool compX (const P& a,const P& b){return !eq(a.X,b.X)?sig(a.X,b.X)<0:sig(a.Y,b.Y)<0;}
namespace std{
  bool operator <  (const P& a,const P& b){return compX(a,b);}
    bool operator == (const P& a,const P& b){return eq(a,b);}
};
typedef valarray<D> Pn;
istream& operator >> (istream& is,Pn& p){D x,y,z;is >> x >> y>>z;p.resize(3);p[0]=x;p[1]=y;p[2]=z; return is;}

const int dim = 3;
D dot(const Pn& a, const Pn& b) {
  return (a * b).sum();
}
Pn cross(const Pn& a, const Pn& b) {
  return a.cshift(+1)*b.cshift(-1)
       - a.cshift(-1)*b.cshift(+1);
}

D len(const Pn&a){
  return sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);
}

struct C {
  P o; D r;
  C(const P &o,D r) : o(o), r(r) { }
};
struct L : public vector<Pn> {
  Pn vec() const {return this->at(1)-this->at(0);}
  L(const Pn &a, const Pn &b){push_back(a); push_back(b);}
  L(){push_back(Pn());push_back(Pn());}
};
bool isIntersectSP(const L &s, const Pn &p) {
  return sig(len(s[0]-p)+len(s[1]-p),len(s[1]-s[0])) <=0; // triangle inequality
};
Pn projection(const L &l, const Pn &p) {
  D t = dot(p-l[0],l.vec()) /(len(l.vec())*len(l.vec()));
  Pn res=l[0];Pn v=l.vec();
  REP(i,3)res[i]+=t*v[i];
  return res;
  // return l[0] + t * l.vec();
}
D distanceSP(const L &s, const Pn &p) {
  const Pn r = projection(s, p);
  if (isIntersectSP(s, r)) return len(r - p);
  return min(len(s[0] - p),len(s[1] - p));
}

// fast zeta transform g(S):=Σ{T ⊆ S} f(T)
template<typename T> vector<T> fzt(int n,vector<T> f){
    REP(v,n)REP(bit,1<<n)if(bit&1<<v)f[bit]+=f[bit^1<<v];
    return f;
}

template<typename T> ostream& operator << (ostream& os, const vector<T>& as){REP(i,as.size()){if(i!=0)os<<" "; os<<as[i];}return os;}


int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
  // ofstream cout( "out" );
	cerr << fixed <<setprecision(20);
	cout << fixed <<setprecision(20);

  while (true) {
    int N,M,R;cin >> N >> M >> R;if(N==0)break;

    vector<Pn> sos;vector<D> rs(N);
    REP(i,N){
      Pn p;cin >> p;sos.push_back(p);cin >> rs[i];
    }
    vector<Pn> ts;vector<D> bs(M);
    REP(i,M){
      Pn p;cin >> p;ts.push_back(p);cin >> bs[i];
    }
    Pn e;cin >>e;
    vector<L> ls(M);REP(i,M)ls[i]=L(ts[i],e);

    //幾何
    vector<vector<bool>> isIntersect(M,vector<bool>(N));
    REP(i,M)REP(j,N){
      if(sig(distanceSP(ls[i],sos[j]),rs[j])<=0){
        if(!(sig(len(ls[i][0]-sos[j]),rs[j])<=0 && sig(len(ls[i][1]-sos[j]),rs[j])<=0))
          isIntersect[i][j]=true;
      }
    }
    vector<D> p(M);REP(i,M)p[i]=bs[i]/(len(ts[i]-e)*len(ts[i]-e));

    //
    D res=0;
    vector<bool> isI(N);
    REP(bit,1<<M){
      fill(ALL(isI),false);
      REP(i,M)if((bit>>i)&1) REP(j,N)if(isIntersect[i][j])isI[j]=true;
      int c=0;REP(j,N)c+=isI[j];
      if(c>R)continue;
      D v=0;REP(i,M)if((bit>>i)&1)v+=p[i];
      res=max(res,v);
    }

    // cout << res <<endl;
    printf("%.20lf\n",res);
    // cout << res <<endl;
  }
}

Measured memory_bytes: 1440