#include <iostream>
#include <iomanip>
#include <vector>
#include <complex>
#include <algorithm>

using namespace std;

#define EPS (1e-12)

struct island_t
{
    complex<double> z;
    double r;
};

struct bridge_t
{
    int s, t;
public:
    bridge_t(int s, int t) : s(s), t(t) { }
    bridge_t(void) { }
};

static vector<island_t> v;
static vector<bridge_t> e;

int cmp(double x, double y)
{
    if(x - y > EPS) return +1;
    if(y - x > EPS) return -1;
    return 0;
}

bool operator <(const bridge_t &b1, const bridge_t &b2)
{
    double d1 = abs(v[b1.s].z - v[b1.t].z) - v[b1.s].r - v[b1.t].r;
    double d2 = abs(v[b2.s].z - v[b2.t].z) - v[b2.s].r - v[b2.t].r;
    if(cmp(d1, d2) != 0) return cmp(d1, d2) < 0;
    if(b1.s != b2.s) return b1.s < b2.s;
    if(b1.t != b2.t) return b1.t < b2.t;
    return false;
}

bool islegal(const bridge_t &b)
{
    complex<double> z1 = v[b.s].z;
    complex<double> z2 = v[b.t].z;

    for(int i = 0; i < e.size(); i++) {
        if(b.s == e[i].s && b.t == e[i].t) return false;
        if(b.t == e[i].s && b.s == e[i].t) return false;

        complex<double> z3 = v[e[i].s].z;
        complex<double> z4 = v[e[i].t].z;

        int c1 = cmp(imag((z1 - z3) / (z4 - z3)), 0.0);
        int c2 = cmp(imag((z2 - z3) / (z4 - z3)), 0.0);
        int c3 = cmp(imag((z3 - z1) / (z2 - z1)), 0.0);
        int c4 = cmp(imag((z4 - z1) / (z2 - z1)), 0.0);

        if(c1 * c2 < 0 && c3 * c4 < 0) return false;
    }

    return true;
}

int main(void)
{
    int n;
    while(cin >> n, n != 0) {
        v.resize(n);

        for(int i = 0; i < n; i++) {
            double x, y, r;
            cin >> x >> y >> r;
            v[i].z = complex<double>(x, y);
            v[i].r = r;
        }

        int m;
        cin >> m;
        e.resize(m);

        for(int i = 0; i < m; i++) {
            int s, t;
            cin >> s >> t;
            --s;
            --t;
            e[i].s = s;
            e[i].t = t;
        }

        vector<int> g(n);

        for(int i = 0; i < n; i++) {
            g[i] = i;
        }

        for(int i = 0; i < m; i++) {
            if(g[e[i].s] != g[e[i].t]) {
                int gt = g[e[i].t];
                int gs = g[e[i].s];
                replace(g.begin(), g.end(), gt, gs);
            }
        }

        vector<bridge_t> f;

        for(int i = 0; i < n; i++) {
            for(int j = i + 1; j < n; j++) {
                if(g[i] != g[j]) {
                    bridge_t b(i, j);
                    if(islegal(b)) f.push_back(b);
                }
            }
        }

        sort(f.begin(), f.end());

        vector<bridge_t> r;
        double d = 0.0;

        for(int i = 0; i < f.size(); i++) {
            if(g[f[i].s] != g[f[i].t]) {
                int gt = g[f[i].t];
                int gs = g[f[i].s];
                replace(g.begin(), g.end(), gt, gs);
                const island_t &vs = v[f[i].s];
                const island_t &vt = v[f[i].t];
                d += abs(vs.z - vt.z) - (vs.r + vt.r);
                r.push_back(f[i]);
            }
        }

        cout << fixed << setprecision(8);

#ifdef DEBUG
        cout << v.size() << endl;

        for(int i = 0; i < v.size(); i++) {
            cout << real(v[i].z) << " " << imag(v[i].z) << " " << v[i].r;
            cout << endl;
        }

        cout << e.size() << endl;

        for(int i = 0; i < e.size(); i++) {
            cout << e[i].s + 1 << " " << e[i].t + 1 << endl;
        }

        cout << r.size() << endl;

        for(int i = 0; i < r.size(); i++) {
            cout << r[i].s + 1 << " " << r[i].t + 1 << endl;
        }
#endif

        cout << fixed << setprecision(8) << d << endl;
    }

    return 0;
}