import java.io.*;
import java.util.*;
import java.text.DecimalFormat;

// 円を表すデータ構造
class Circle
{
	public double r, x, y;

	public double dist( Circle c )
	{
		return Math.sqrt( (x-c.x)*(x-c.x) + (y-c.y)*(y-c.y) ) - r - c.r;
	}

	public static Circle readFromSt(StreamTokenizer st) throws IOException
	{
		Circle c = new Circle();
		st.nextToken(); c.r = st.nval;
		st.nextToken(); c.x = st.nval;
		st.nextToken(); c.y = st.nval;
		return c;
	}
}

// Circle[] のソート用比較関数（x座標順）
class CmpX implements Comparator
{
	public int compare(Object lhs, Object rhs)
	{
		double lv = ((Circle) lhs).x;
		double rv = ((Circle) rhs).x;
		return lv<rv ? -1 : lv>rv ? 1 : 0;
	}
}

// Circle[] のソート用比較関数（y座標順）
class CmpY implements Comparator
{
	public int compare(Object lhs, Object rhs)
	{
		double lv = ((Circle) lhs).y;
		double rv = ((Circle) rhs).y;
		return lv<rv ? -1 : lv>rv ? 1 : 0;
	}
}

// メインルーチン
public class circle_inaba
{
	// main : 入力を読んでsolveを呼んで返値を表示するだけ
	public static void main( String[] arg ) throws Exception
	{
		DecimalFormat fmt = new DecimalFormat("0.00000000");

		StreamTokenizer st =
			new StreamTokenizer(
				new BufferedReader(
					new InputStreamReader(System.in)));

		while( st.nextToken() == StreamTokenizer.TT_NUMBER )
		{
			int n = (int) st.nval;
			if( n == 0 )
				break;

			Circle[] cs = new Circle[n];
			for(int i=0; i<n; ++i)
				cs[i] = Circle.readFromSt(st);

			double d = solve(cs);
			System.out.println( fmt.format(d) );
		}
	}

	// solve :
	static double solve( Circle[] cs )
	{
		// 半径の最大値をあらかじめ計算しておく
		double MinR = Double.MAX_VALUE;
		double MaxR = Double.MIN_VALUE;
		for(int i=0; i<cs.length; ++i) {
			MaxR = Math.max(MaxR, cs[i].r);
			MinR = Math.min(MinR, cs[i].r);
		}
		assert MaxR/MinR <= 2.0 : "ratio does not exceed 2";

		// x座標でソート
		Arrays.sort( cs, new CmpX() );

		// 再帰的に最近円対距離を計算
		return closest(cs, 0, cs.length, MaxR);
	}

	// closest
	//  分割統治による、最近円対距離を求めるアルゴリズム
	//  最近点対問題の典型アルゴリズムを、円の半径を考慮して微調整したもの
	//
	//    - cs_x : x座標昇順にソートされた円のリスト
	//    - b, e : cs_x[b..e) の最近距離を求める
	//             ↑に相当する配列スライスを作るのが面倒だったのでこれで
	//    -    R : 最大半径。探索範囲を決めるのにこれが必要となる。
	//
	static double closest( Circle[] cs_x, int b, int e, double R )
	{
		// ４個以下のとき（２個２個以上に分けられない時）は
		// 普通に全ペアの距離を計算して最短のを返す。おしまい。

		if( e-b < 4 )
		{
			double d = Double.MAX_VALUE;
			for(int i=b;   i<e; ++i)
			for(int j=i+1; j<e; ++j)
				d = Math.min( d, cs_x[i].dist(cs_x[j]) );
			assert d > 0.0 : "non-overlapping";
			return d;
		}

		// ４個より大きいときは、分割統治。
		// まず、配列を真ん中で左右に分ける :: cs_x[b..m) と cs_x[m..e)。
		// 直線 centerX の左右に分ける、と言ってもよい。

		int m = (b+e)/2;
		double centerX = (cs_x[m-1].x + cs_x[m].x) / 2;

		// 左右それぞれの最近円対距離を計算して、短い方を覚えておく :: d
		// 完全２分割しながら再帰しているので、再帰の深さは log_2(N) である。

		double d = Math.min( closest(cs_x, b, m, R), closest(cs_x, m, e, R) );

		// さて、すると、全体 cs_x[b..e) の最近円対距離は
		//    d
		// であるか、または
		//    centerXの近く(左側)にある円とcenterXの近く(右側)にある円との距離
		// であるか、どちらかである。

		// なので、まずは centerX の近くにある円をとりあえず集めてみる :: cs_y
		// 「近く」はどのくらい近ければいいかというと、d+2*R くらい近ければよい。
		// これ以上遠いと、中心が反対側にある円との距離が明らかにd以上になるので。

		Circle[] cs_y = new Circle[e-b];
		int NN = 0;
		for(int i=b; i<e; ++i)
			if( Math.abs(centerX-cs_x[i].x) < d+2*R )
				cs_y[NN++] = cs_x[i];

		// 近場に０個か１個しかなかったら
		// 円対が作れないので答えは d に決定。おしまい。

		if( NN <= 1 )
			return d;

		// 近いもの軍団が２個以上あったら、今度はy座標でソート

		Arrays.sort( cs_y, 0, NN, new CmpY() );

		// 普通に２重ループで、距離dより短い円対がないか探していく。
		// y座標がd+2*R以上離れたら距離は当然d以上なので、
		// この条件で内部ループを打ち切るのもお忘れなく。

		for(int i=0;   i<NN; ++i)
		for(int j=i+1; j<NN && (cs_y[j].y-cs_y[i].y)<d+2*R; ++j)
			d = Math.min(d, cs_y[i].dist(cs_y[j]));

		// … 一見すると、最後の２重ループは最悪 O(N^2) に見える。
		// ところが、左側円どうし、右側円どうしの距離は必ず d 以上。

		// 従って、x軸方向にもy軸方向にも d+2*R の範囲という狭い領域には、
		// あんまり沢山の円は密集できない。８個か９個が限界だと思う（適当）。
		// ので、２重ループの内周の回数は実は定数で抑えられる。

		// よって、このループは O(N)。
		// 途中でsortしてるとこがO(N logN) なので、
		// 再帰の深さをかけ算すると、全体としてはこのソースの計算量は
		// O(N logN logN) となる。

		// 最近"点"対問題の場合は +2*R という邪魔な項を考えなくていいので
		// もう少し楽に考えられますよー

		assert d > 0.0 : "non-overlapping";
		return d;
	}
}