#include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>

#define show(x) cerr << #x << " = " << x << endl

using namespace std;
using ll = long long;
using ld = long double;

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
    os << "sz:" << v.size() << "\n[";
    for (const auto& p : v) {
        os << p << ",";
    }
    os << "]\n";
    return os;
}


struct Point {
    ld x;
    ld y;
    ld l;
};

ostream& operator<<(ostream& os, const Point& v)
{
    cout << "(" << v.x << " " << v.y << " " << v.l << ")";
    return os;
}

Point two(const Point& p1, const Point& p2)
{
    const ld L = (p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y);
    const ld l = sqrt(L);
    const ld e = (L + (p1.l * p1.l) - (p2.l * p2.l)) / (2 * l);
    const ld hh = p1.l * p1.l - e * e;
    const ld h = (hh > 0) ? sqrt(hh) : 0;
    const ld x = ((l - e) * p1.x + e * p2.x) / l;
    const ld y = ((l - e) * p1.y + e * p2.y) / l;
    return Point{x, y, h};
}

Point three(const Point& p1, const Point& p2, const Point& p3)
{
    const ld a11 = p2.x - p3.x;
    const ld a12 = p2.y - p3.y;
    const ld a21 = p1.x - p2.x;
    const ld a22 = p1.y - p2.y;
    const ld b1 = (ld)(p3.l * p3.l - p2.l * p2.l - p3.x * p3.x + p2.x * p2.x - p3.y * p3.y + p2.y * p2.y) / 2;
    const ld b2 = (ld)(p2.l * p2.l - p1.l * p1.l - p2.x * p2.x + p1.x * p1.x - p2.y * p2.y + p1.y * p1.y) / 2;

    const ld det = a11 * a22 - a12 * a21;
    const ld x = (a22 * b1 - a12 * b2) / det;
    const ld y = (-a21 * b1 + a11 * b2) / det;
    const ld hh = p1.l * p1.l - (x - p1.x) * (x - p1.x) - (y - p1.y) * (y - p1.y);
    const ld h = (hh > 0) ? sqrt(hh) : 0;
    return Point{x, y, h};
}

int main()
{
    while (true) {
        int n;
        cin >> n;
        if (n == 0) {
            break;
        }
        vector<Point> p(n);
        for (int i = 0; i < n; i++) {
            auto& P = p[i];
            cin >> P.x >> P.y >> P.l;
        }

        ld maxh = 0;
        for (int i = 0; i < n; i++) {
            const ld h = p[i].l;
            const ld xi = p[i].x;
            const ld yi = p[i].y;
            bool ok = true;
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    continue;
                }
                if ((xi - p[j].x) * (xi - p[j].x) + (yi - p[j].y) * (yi - p[j].y) + h * h > p[j].l * p[j].l) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                maxh = max(maxh, h);
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                const Point P = two(p[i], p[j]);
                const ld x = P.x;
                const ld y = P.y;
                const ld h = P.l;
                bool ok = true;
                for (int l = 0; l < n; l++) {
                    if (i == l or j == l) {
                        continue;
                    }
                    if ((x - p[l].x) * (x - p[l].x) + (y - p[l].y) * (y - p[l].y) + h * h > p[l].l * p[l].l) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    maxh = max(maxh, h);
                }
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    const Point P = three(p[i], p[j], p[k]);
                    const ld x = P.x;
                    const ld y = P.y;
                    const ld h = P.l;
                    bool ok = true;
                    for (int l = 0; l < n; l++) {
                        if (i == l or j == l or k == l) {
                            continue;
                        }
                        if ((x - p[l].x) * (x - p[l].x) + (y - p[l].y) * (y - p[l].y) + h * h > p[l].l * p[l].l) {
                            ok = false;
                            break;
                        }
                    }
                    if (ok) {
                        maxh = max(maxh, h);
                    }
                }
            }
        }
        cout << fixed << setprecision(10) << maxh << endl;
    }
    return 0;
}

Measured memory_bytes: 3300