#include <bits/stdc++.h>
using namespace std;
#define REP(i, s, e) for(int i = (int)(s); i < (int)(e); ++i)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define all(X) (X).begin(), (X).end()

typedef double D;
const D EPS = 1e-10;
using P = valarray<D>; // 使うときは、Originで初期化する！！
const P Origin = {(D)0.0, (D)0.0, (D)0.0};
#define x(P) (P)[0]
#define y(P) (P)[1]
#define z(P) (P)[2]
#define SQ(Q) ((Q)*(Q))
#define curr(P, idx) (P)[(idx)]
#define next(P, idx) (P)[((idx)+1)%(P).size()]
#define prev(P, idx) (P)[((idx)+(P).size()-1)%(P).size()]
namespace std {
    bool operator < (const P& a, const P& b) {
        if(x(a) != x(b)) return x(a) < x(b);
        if(y(a) != y(b)) return y(a) < y(b);
        return z(a) < z(b);
    }
}


struct L : array<P, 2> {
    L() {at(0) = at(1) = Origin;}
    L(const P& a, const P& b) {
        at(0) = a;
        at(1) = b;
    }
};
D dot(const P& a, const P& b) {
    auto p = a*b;
    return p.sum();
}
P cross(const P& a, const P& b) {
    P ret(3);
    x(ret) = y(a) * z(b) - y(b) * z(a);
    y(ret) = z(a) * x(b) - z(b) * x(a);
    z(ret) = x(a) * y(b) - x(b) * y(a);
    return ret;
}
D norm(const P& p) {
    return sqrt(dot(p, p));
}
//----------------------------------------
//直線・線分の当たり判定、円・直線、線分の当たり判定、距離等 
// verify aoj 2641
bool isHitLP(const L&l ,const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    return abs(norm(cross(v, v1))) < EPS;
}
bool isHitSP(const L& l, const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    P u = l[0] - l[1], u1 = p - l[1];
    return abs(norm(cross(v, v1))) < EPS && norm(v1) < norm(v) + EPS
            && abs(norm(cross(u, u1))) < EPS && norm(u1) < norm(u) + EPS; 
}
D distLP(const L& l, const P& p) {
    if(isHitLP(l, p)) return (D)0.0;
    P AB = l[1] - l[0];
    P AP = p - l[0];
    if(abs(norm(AB)) < EPS) return norm(AP);
    return norm(cross(AB, AP)) / norm(AB);
}
D distSP(const L& l, const P& p) {
    if(isHitSP(l, p)) return (D)0.0;
    return min({norm(p - l[0]), norm(p - l[1]), distLP(l, p)});
}
struct C{
    P p;
    D r;
};
bool isHitPC(const P& p, const C& c) {
    return norm(p - c.p) < c.r + EPS;
}
vector<P> crossPointLC(const L&l ,const C& cir) {
    P s = l[0] - cir.p;
    P d = l[1] - l[0];
    auto A = dot(d, d), B = dot(d, s), C = dot(s, s) - SQ(cir.r);
    auto DD = (SQ(B) - A * C);
    vector<D> t;
    if(abs(DD) < 0) t.pb(B / A);
    else if(DD < 0) ;
    else {
        t.pb((-B + sqrt(DD)) / A);
        t.pb((-B - sqrt(DD)) / A);
    }
    vector<P> ret;
    rep(i, t.size()) ret.push_back(s + d * t[i]);
    rep(i, ret.size()) ret[i] += cir.p;
    return ret;
}
vector<P> crossPointSC(const L&l ,const C& c) {
    vector<P> ps = crossPointLC(l, c);
    sort(all(ps));
    auto it = ps.begin();
    while(it != ps.end()) {
        assert(abs(norm(*it - c.p) - c.r) < EPS);
        if(isHitSP(l, *it)) ++it;
        else it = ps.erase(it);
    }
    return ps;
}
bool isHitLC(const L& l, const C& c) {
    return distLP(l, c.p) < c.r + EPS;
}
bool isHitSC(const L& l, const C& c) {
    return crossPointSC(l, c).size() > 0;
}

const int MAX_N = 2001;

int main() {
    int n, m, r;
    while(cin >> n >> m >> r) {
        if(n == 0 && m == 0 && r == 0) break;
        vector<C> cs(n);
        rep(i, n) {
            D x, y, z, r;
            cin >> x >> y >> z >> r;
            cs[i] = {{x, y, z}, r};
        }
        vector<P> ps(m);
        vector<D> lights(m);
        rep(i, m) {
            D x, y, z, l;
            cin >> x >> y >> z >> l;
            ps[i] = {x, y, z};
            lights[i] = l;
        }
        P p;
        {
            D x, y, z;
            cin >> x >> y >> z;
            p = {x, y, z};
        }
        using B = bitset<MAX_N>;
        vector<B> bs(m);
        rep(i, m) {
            rep(j, n) {
                if(isHitSC({p, ps[i]}, cs[j])) bs[i].set(j);
            }
            lights[i] = lights[i]/(dot(p - ps[i], p - ps[i]));
        }
        D ans = (D)0.0;
        for(int mask = (1<<m)-1; mask >= 1; --mask) {
            // cout << "  mask: " << B(mask);
            D sum = 0.0;
            rep(i, m) if(mask&(1<<i)) sum += lights[i];
            // cout << " sum: " << sum << endl;
            if(sum < ans) continue;
            B tmp;
            rep(i, m) if(mask&(1<<i)) tmp |= bs[i];
            if(tmp.count() <= r) ans = sum;
            // cout << "   " <<tmp << endl;
        }

        // cout << "ans ";
        printf("%.15lf\n", ans);
    } 
    return 0;
}


Measured memory_bytes: 3200