#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")
#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define ld long double
#define ull unsigned long long
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define rev(x) reverse(x.begin(), x.end())
#define fi first
#define se second
#define pb push_back
#define PI 3.14159265359
typedef pair<int, int>	pii;
typedef pair<ll, ll>	pl;
typedef vector<int>		vi;
typedef vector<ll>		vl;
typedef vector<pii>		vpii;
typedef vector<pl>		vpl;
typedef vector<vi>		vvi;
typedef vector<vl>		vvl;
bool sortbysec(const pair<int,int> &a,const pair<int,int> &b){return (a.second < b.second);}
#define sortpairbysec(x) sort(all(x), sortbysec)
bool sortcond(const pair<int,int> &a,const pair<int,int> &b){
    if (a.fi != b.fi){
        return a.fi < b.fi;
    } else {
        return a.se > b.se;
    }
}
struct myComp {
    constexpr bool operator()( pii const& a, pii const& b) const noexcept
    {
        if (a.first != b.first){
            return a.first < b.first;
        } else {
            return a.second > b.second;
        }
    }
};
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
ll rng(ll lim) {
    uniform_int_distribution<ll> uid(0,lim-1);
    return uid(rang);
}

const int mod = 998244353;
const int N = 3e5, M = N;
const ll inf = 1e18;
//=======================
struct edmond {

    vector<vector<ll>> capacity;
    vector<vector<int>> adj;
    int graph_size;

    void init(int siz){
        graph_size = siz;
        capacity.resize(siz, vector<ll>(siz));
        adj.resize(siz);
    }

    void add_edge(int u, int v, ll cap){
        adj[u].pb(v);
        adj[v].pb(u);
        capacity[u][v] = cap;
    }

    ll bfs(int s, int t, vector<int>& parent) {
        fill(parent.begin(), parent.end(), -1);
        parent[s] = -2;
        queue<pair<int, ll>> q; // edmond karp
        // stack<pair<int, ll>> q; // ford fulkerson
        q.push({s, inf});

        while (!q.empty()) {
            int cur = q.front().first;
            ll flow = q.front().second;
            q.pop();

            for (int next : adj[cur]) {
                if (parent[next] == -1 && capacity[cur][next]) {
                    parent[next] = cur;
                    ll new_flow = min(flow, capacity[cur][next]);
                    if (next == t) return new_flow;
                    q.push({next, new_flow});
                }
            }
        }

        return 0;
    }

    ll maxflow(int s, int t) {
        ll flow = 0;
        vector<int> parent(graph_size);
        ll new_flow;

        while (true) {
            new_flow = bfs(s, t, parent);
            if (new_flow == 0) break;
            flow += new_flow;
            int cur = t;
            while (cur != s) {
                int prev = parent[cur];
                capacity[prev][cur] -= new_flow;
                capacity[cur][prev] += new_flow;
                cur = prev;
            }
        }

        return flow;
    }
};
//=======================
// & - bitwise AND; | - bitwise OR; ^ - bitwise XOR
// cout.precision(7);
// next_permutation(arr.begin(), arr.end());
// long long long long long long long long long long long long long long long long long long long long long long long long long long long
// priority_queue<int, vector<int>, greater<int>> a; (min heap)
// ll hash1 = hash<string>{}(to_string(1));
// always lower_bound
// __builtin_clz(n) count leading zeros

vl a;
ll n, m, k, q;

ll dist(ll x1, ll y1, ll x2, ll y2){
    return (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
}

void solve(int tc) {
    int i, j;
    cin >> n;
    edmond flow;
    flow.init(n+2);
    int s = n;
    int t = n+1;

    vpii coords(n);
    vi radius(n);
    ll sum = 0;
    fo(i, n){
        int x, y, r, v;
        cin >> x >> y >> r >> v;
        coords[i] = {x, y};
        radius[i] = r;
        if (v > 0) {   
            sum += v;
            flow.add_edge(s, i, v);
        }
        if (v < 0) {
            flow.add_edge(i, t, -v);
        }
    }

    fo(i, n){
        fo(j, n){
            if (i == j) continue;
            int x1 = coords[i].fi;
            int y1 = coords[i].se;
            int x2 = coords[j].fi;
            int y2 = coords[j].se;
            if (dist(x1, y1, x2, y2) <= radius[i]*radius[i]){
                flow.add_edge(i, j, inf);
            }
        }
    }
    cout << "Case #" << tc << ": " << sum - flow.maxflow(s, t) << "\n";
}
 
int main() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());

    int t = 1;
    cin >> t;
    int i;
    fo(i, t) {
        solve(i+1);
    }
    return 0;
}