#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstring>
#include <sstream>
#include <fstream>
#include <cassert>
#include <ctime>
#include <list>
#include <numeric>
#include <iomanip>


using namespace std;
static const double EPS = 1e-6;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PI;
#ifndef M_PI
const double M_PI=acos(-1);
#endif
#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 mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define SZ(a) (int((a).size()))
#define F first
#define S second
int dx[]={0,1,0,-1,1,1,-1,-1},dy[]={1,0,-1,0,1,-1,1,-1};


struct P {
  double x, y, z;
  P(){};
  P(double x,double y,double z):x(x),y(y),z(z){};
  P operator-(const P r){
    return
      P(x-r.x,y-r.y,z-r.z);
  }

  P operator+(const P r){
    return
      P(x+r.x,y+r.y,z+r.z);
  }  

  P operator*(double r){
    return
      P(x*r,y*y,z*r);
  }
};

P operator*(double r,const P a){
  return
    P(a.x*r,a.y*r,a.z*r);
}

double norm(const P a){
  return
    sqrt(a.x*a.x + a.y*a.y + a.z*a.z);
}

double area(const P &a, const P &b) {
  return
    sqrt(pow(a.y*b.z-a.z*b.y,2)+
         pow(a.z*b.x-a.x*b.z,2)+
         pow(a.x*b.y-a.y*b.x,2));
}


double dist(P l1, P l2, P c) {
  return
    area(c - l1, l2 - l1) / norm(l2 - l1);
}


int n,m,r;
P sp[2000],tp[2000];
double sr[2000];
double tr[2000];

set<int> memo[1<<15];
bool vis[1<<15];

set<int> unit(set<int> a, set<int> &b){
  FOR(it,b)a.insert(*it);
  return a;
}

void rec(int st){
  if(vis[st]) return;
  //cout << "rec " << st << endl;
  vis[st] = true;
  bool ok = false;
  rep(i,m)
    if(st&(1<<i)){
      int ne=st^(1<<i);
      rec(ne);
      if(!ok) memo[st]=unit(memo[ne],memo[1<<i]);
      ok=true;
    }
}

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

void solve(){
  memset(vis,0,sizeof(vis));
  rep(i,n) cin >> sp[i].x >> sp[i].y >> sp[i].z >> sr[i];
  rep(i,m) cin >> tp[i].x >> tp[i].y >> tp[i].z >> tr[i];

  rep(i,(1<<m)) memo[i].clear();
  P ee;
  cin >> ee.x >> ee.y >> ee.z;


  vis[0]=true;
  rep(i,m){
    vis[1<<i]=true;
    rep(j,n){
      if(norm(sp[j]-ee) <= sr[j] && norm(tp[i]-sp[j]) <= sr[j]) continue;
      P y=sp[j]-tp[i];
      P x=ee-tp[i];
      P nearest=tp[i]+dot(x,y)/norm(x)/norm(x)*x;
      if(norm(nearest-ee) + norm(nearest-tp[i]) < norm(tp[i]-ee) + EPS &&
         norm(nearest-sp[j]) <= sr[j])
        memo[1<<i].insert(j);
      else if((norm(tp[i]-sp[j]) <= sr[j]) ^ (norm(ee-sp[j]) <= sr[j]))
        memo[1<<i].insert(j);
    }

    /*
    cout << i;
    FOR(it,memo[1<<i]) cout << ' ' << *it ;
    cout << endl;
    */
  }

  //rec((1<<m)-1);

  double ans=0;
  rep(i,1<<m){
    double tans=0;
    rep(j,m){
      if(!(i&(1<<j))) continue;
      tans += tr[j]/pow(norm(tp[j]-ee),2);
    }
    if(ans>=tans) continue;

    set<int> need;
    rep(j,m){
      if(!(i&(1<<j))) continue;
      FOR(it,memo[1<<j]) need.insert(*it);
      if(SZ(need)>r) break;
    }
    if(SZ(need) <= r) ans=tans;
  }

  printf("%.8f\n",ans);
  //cout << ans << endl;
}

main(){
  while(cin >> n >> m >> r,n) solve();
}

Measured memory_bytes: 3428