#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)n;++i)

using namespace std;

typedef pair<int,int>P;
typedef pair<double,double>pdd;

const int MAX_N = 12;

int x[MAX_N],y[MAX_N],l[MAX_N];
int n;

double dir(double x1,double y1,double z1,double x2,double y2,double z2)
{
    return (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1);
}

pdd inter(double a1,double b1,double a2,double b2)
{
    pdd p;
    p.first = (b2-b1)/(a1-a2);
    p.second = p.first*a1 + b1;
    return p;
}

bool possible(double r1,double r2,double r3)
{
    if(r1 + r2 > r3 && r2 + r3 > r1 && r1 + r3 > r2){
        return true;
    }
    return false;
}

int main()
{
    while(1){
        scanf("%d",&n);
        if(n == 0){
            break;
        }
        double mx = 0.0;
        rep(i,n){
            scanf("%d%d%d",&x[i],&y[i],&l[i]);
        }
        bool flag;
        rep(i,n){
            flag = false;
            rep(j,n){
                if(j != i){
                    if(dir(x[i],y[i],l[i],x[j],y[j],0) > l[j]*l[j]){
                        flag = true;
                        break;
                    }
                }
            }
            if(!flag){
                mx = max(mx,(double)l[i]);
            }
        }

        rep(i,n){
            for(int j=i+1;j<n;j++){
                double r = sqrt(dir(x[i],y[i],0,x[j],y[j],0));
                if(possible(r,l[i],l[j])){
                    double t = (r*r + l[i]*l[i] - l[j]*l[j]) / (2*r);
                    double h = sqrt(l[i]*l[i]-t*t);
                    double s1 = ((r-t)*x[i] + t*x[j]) / r;
                    double t1 = ((r-t)*y[i] + t*y[j]) / r;
                    flag = false;
                    rep(k,n){
                        if(k != i && k != j){
                            if(dir(s1,t1,h,x[k],y[k],0) > l[k]*l[k]){
                                flag = true;
                                break;
                            }
                        }
                    }
                    if(!flag){
                        mx = max(mx,h);
                    }
                }
            }
        }

        rep(i,n){
            for(int j=i+1;j<n;j++){
                for(int k=j+1;k<n;k++){
                    double r1 = sqrt(dir(x[i],y[i],0,x[j],y[j],0));
                    double r2 = sqrt(dir(x[j],y[j],0,x[k],y[k],0));
                    double r3 = sqrt(dir(x[i],y[i],0,x[k],y[k],0));
                    if(possible(r1,l[i],l[j]) && possible(r2,l[j],l[k]) && possible(r3,l[k],l[i]) && possible(r1,r2,r3)){
                        double xx,yy,zz;
                        double dd1 = (x[i]*x[i] - x[j]*x[j]) + (y[i]*y[i] - y[j]*y[j]) - (l[i]*l[i] - l[j]*l[j]);
                        double dd2 = (x[j]*x[j] - x[k]*x[k]) + (y[j]*y[j] - y[k]*y[k]) - (l[j]*l[j] - l[k]*l[k]);
                        if(y[i] == y[j]){
                            xx = dd1 / (2.0*(x[i]-x[j]));
                            double a2 = -(double)(x[j] - x[k])/(y[j] - y[k]);
                            double b2 = dd2 / (2.0*(y[j]-y[k]));
                            yy = a2*xx + b2;
                            zz = sqrt(l[i]*l[i] - (xx-x[i])*(xx-x[i]) - (yy-y[i])*(yy-y[i]));
                        }else{
                            double a1 = -(double)(x[i] - x[j])/(y[i] - y[j]);
                            double b1 = dd1 / (2.0*(y[i]-y[j]));
                            if(y[j] == y[k]){
                                xx = dd2 / (2.0*(x[j]-x[k]));
                                yy = a1*xx + b1;
                                zz = sqrt(l[i]*l[i] - (xx-x[i])*(xx-x[i]) - (yy-y[i])*(yy-y[i]));
                            }else{
                                double a2 = -(double)(x[j] - x[k])/(y[j] - y[k]);
                                double b2 = dd2 / (2.0*(y[j]-y[k]));
                                pdd p = inter(a1,b1,a2,b2);
                                xx = p.first,yy = p.second;
                                zz = sqrt(l[i]*l[i] - (xx-x[i])*(xx-x[i]) - (yy-y[i])*(yy-y[i]));
                            }
                        }
                        flag = false;
                        rep(m,n){
                            if(m != i && m != j && m != k){
                                if(dir(xx,yy,zz,x[m],y[m],0)>l[m]*l[m]){
                                    flag = true;
                                    break;
                                }
                            }
                        }
                        if(!flag){
                            mx = max(mx,zz);
                        }
                    }
                }
            }
        }
        printf("%.10f\n",mx);
    }
	return 0;
}

Measured memory_bytes: 3184