#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

#define fi first
#define se second
#define mp make_pair
#define fastIO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

struct FlowEdge {
    int v, u;
    ll cap, flow = 0;
    FlowEdge(int v, int u, ll cap) : v(v), u(u), cap(cap) {}
};

struct Dinic {
    const ll flow_inf = (ll)1e18;
    vector<FlowEdge> edges;
    vector<vector<int>> adj;
    int nn, mm = 0;
    int s, t;
    vector<int> level, ptr;
    queue<int> q;
    Dinic(int nn, int s, int t) : nn(nn), s(s), t(t) {
        adj.resize(nn);
        level.resize(nn);
        ptr.resize(nn);
    }
    void add_edge(int v, int u, ll cap){
        edges.push_back({v, u, cap});
        edges.push_back({u, v, 0});
        adj[v].push_back(mm);
        adj[u].push_back(mm + 1);
        mm += 2;
    }
    bool bfs() {
        while(!q.empty()){
            int v = q.front();
            q.pop();
            for(int id : adj[v]){
                if(edges[id].cap - edges[id].flow < 1)
                    continue;
                if(level[edges[id].u] != -1)
                    continue;
                level[edges[id].u] = level[v] + 1;
                q.push(edges[id].u);
            }
        }
        return level[t] != -1;
    }
    ll dfs(int v, ll pushed){
        if(pushed == 0)
            return 0;
        if(v == t)
            return pushed;
        for(int &cid = ptr[v]; cid < (int)adj[v].size(); cid ++ ){
            int id = adj[v][cid];
            int u = edges[id].u;
            if(level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
                continue;
            ll tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
            if(tr == 0)
                continue;
            edges[id].flow += tr;
            edges[id ^ 1].flow -= tr;
            return tr;
        }
        return 0;
    }
    ll flow(){
        ll f = 0;
        while(true){
            fill(level.begin(), level.end(), -1);
            level[s] = 0;
            q.push(s);
            if(!bfs())
                break;
            fill(ptr.begin(), ptr.end(), 0);
            while(ll pushed = dfs(s, flow_inf)){
                f += pushed;
            }
        }
        return f;
    }
    vector<bool> vis;
    void dfs_t(int node){
        if(vis[node]) return;
        vis[node]=true;
        for(auto x : adj[node]){
            if(edges[x].cap - edges[x].flow > 0){
                dfs_t(edges[x].u);
            }
        }
    }
};

const int N = (int)505;
int x[N], y[N], s[N], r[N];

void solve(int idx){
    int n;
    cin >> n;
    Dinic dd(2 * n + 2, 0, 2 * n + 1);
    int profit = 0;
    for(int i = 1; i <= n; i ++ ){
        cin >> x[i] >> y[i] >> r[i] >> s[i];
        if(s[i] > 0){
            profit += s[i];
            dd.add_edge(n + i, 2 * n + 1, s[i]);
        }
        else if(s[i] < 0){
            dd.add_edge(0, i, -s[i]);
        }
        dd.add_edge(i, n + i, (ll)1e18);
        dd.add_edge(n + i, i, (ll)1e18);
    }
    for(int i = 1; i <= n; i ++ ){
        for(int j = 1; j <= n; j ++ ){
            if(j == i) continue;
            if((x[j] - x[i]) * (x[j] - x[i]) + (y[j] - y[i]) * (y[j] - y[i]) <= (r[i] * r[i]))
            dd.add_edge(n + j, i, (ll)1e18);
        }
    }
    cout << "Case #" << idx << ": " << profit - dd.flow() << "\n";
}

int main(){
    fastIO;
    int tc;
    cin >> tc;
    for(int iq = 1; iq <= tc; iq ++ )
        solve(iq);
    return 0;
}