#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <climits>

using namespace std;

#define POW2(x) ( (x) * (x) )
class Cell{
public:
  double x, y, z, r;
  Cell(double x_, double y_, double z_, double r_)
    : x(x_), y(y_), z(z_), r(r_){}
  void dump(){
    cout << "x:" << x << " y:" << y << " z:" << z << " r:" << r << endl;
  }
};

int n;
vector<Cell> cells;
vector<vector<double> > costs;

vector<vector<int> > groups;


double direct_cost(int i1, int i2){
  if (i1 == i2) return 0.0;
  
  Cell& c1 = cells[i1];
  Cell& c2 = cells[i2];
  double d = sqrt(POW2(c1.x-c2.x) + POW2(c1.y-c2.y) + POW2(c1.z-c2.z)) - c1.r - c2.r;
  //  c1.dump();
  //c2.dump();
  //  cout << "makes distance " << d << endl;
  if (d <= 0)
    return 0;
  else
    return d;
}

double solve(){
  groups.clear();
  costs.clear();
  costs.resize(n);
  for (int i=0; i<n; ++i){
    costs[i].resize(n);
  }

  // calculate DIRECT cost
  
  for (int i=0; i<n; ++i){
    for (int j=0; j<n; ++j){
      costs[i][j] = direct_cost(i,j);
    }
  }

  // calculate SHORTEST cost from i to j
  for (int i=0; i<n; ++i){
    for (int j=0; j<n; ++j){
      for (int k=0; k<n; ++k){
	costs[i][j] = min(costs[i][j], costs[i][k]+costs[j][k]);
      }
    }
  }

  /*
  // do grouping
  for (int i=0; i<n; ++i){
    int added_to_somewhere = false;
    for (int j=0; j<groups.size(); ++j){
      if (costs[i][groups[j][0]] == 0.0){
	groups[j].push_back(i);
	added_to_somewhere = true;
	break;
      }
    }
    if (!added_to_somewhere){
      groups.resize(groups.size()+1);
      groups[groups.size()-1].push_back(i);
    }
  }
  
  // initialize group costs
  int nGroups = groups.size();
  vector<vector<double> > gcost;
  gcost.resize(nGroups);
  for (int i=0; i<nGroups; ++i){
    gcost[i].resize(nGroups);
  }

  // calculate DIRECT cost
  for (int i=0; i<nGroups; ++i){
    gcost[i][i] = 0.0;
    for (int j=0; j<nGroups; ++j){
      gcost[i][j] = costs[groups[i][0]][groups[j][0]];
    }
  }

  // calclulate actual cost
  
  for (int i=0; i<nGroups; ++i){
    for (int j=0; j<nGroups; ++j){
      for (int k=0; k<nGroups; ++k){
	gcost[i][j] = min(gcost[i][j], gcost[i][k]+gcost[j][k]);
      }
    }
  }

  */
  //

int  nGroups = n;
  vector<vector<double> >& ccc = costs;
    
  double d = 0.0;
  
  vector<int> aho;
  aho.push_back(0);
  while (aho.size() < nGroups){
    double  min_cost = DBL_MAX;
    int min_i = -1;
    for (int i=0; i<aho.size(); ++i){
      for (int j=1; j<nGroups; ++j){

	if (j == aho[i]) continue;
	bool _found = false;
	for (int k=0; k<aho.size(); k++){
	  if (j == aho[k]) { _found = true; break; }
	}
	if (_found) continue;
	
	if (j != aho[i]){
	  double cost = ccc[j][aho[i]];
	  //	  double cost = direct_cost(j, aho[i]);
	  if (min_cost > cost){
	    min_cost = cost;
	    min_i = j;
	  }
	}
      }
    }
    aho.push_back(min_i);
    d += min_cost;
  }

  return d;
}

int main(){
  for ( ; ; ){
    cin >> n;
    if (!n) break;

    cells.clear();
    
    for (int i=0; i<n; ++i){
      double x, y, z, r;
      cin >> x >> y >> z >> r;
      cells.push_back(Cell(x, y, z, r));
    }

    printf("%0.3f\n", solve());
  }
  
  return 0;
}