import java.util.*;
import java.io.*;

public class moveaway_font
{
   public static void main(String[] args) throws Exception
   {
      PrintWriter out = new PrintWriter(System.out);
      new moveaway_font(new FastScanner(System.in), out);
      out.close();
   }

   class Vec2
   {
      double x, y;

      Vec2(double x, double y)
      {
         this.x = x;
         this.y = y;
      }

      boolean eq(Vec2 rhs)
      {
         return Geom.eq(x, rhs.x) && Geom.eq(y, rhs.y);
      }

      Vec2 add(Vec2 rhs)
      {
         return new Vec2(x+rhs.x, y+rhs.y);
      }

      Vec2 sub(Vec2 rhs)
      {
         return new Vec2(x-rhs.x, y-rhs.y);
      }

      Vec2 scale(double s)
      {
         return new Vec2(x*s, y*s);
      }

      double mag2()
      {
         return x*x + y*y;
      }

      double mag()
      {
         return Math.sqrt(mag2());
      }

      double dist(Vec2 rhs)
      {
         return sub(rhs).mag();
      }

      Vec2 normalize()
      {
         return scale(1./mag());
      }

      public String toString()
      {
         return String.format("<%.3f, %.3f>", x, y);
      }
   }

   class Circle2
   {
      Vec2 center;
      double radius;

      Circle2(Vec2 center, double radius)
      {
         this.center = center;
         this.radius = radius;
      }

      boolean eq(Circle2 rhs)
      {
         return center.eq(rhs.center) && Geom.eq(radius, rhs.radius);
      }

      boolean contains(Vec2 pos)
      {
         double d = pos.dist(center);
         return d < radius + Geom.EPS;
      }

      Vec2[] intersect(Circle2 rhs)
      {
         if (eq(rhs))
            return new Vec2[0];
      
         double L = radius;
         double R = rhs.radius;
         double B = center.dist(rhs.center);
     
         int nSols = Geom.testTriangle(L, R, B);
         if (nSols == 0)
            return new Vec2[0];

         double c = (B*B+L*L-R*R) / (2*B);
         double b = Math.sqrt(Math.abs(L*L-c*c));
         Vec2 u = rhs.center.sub(center).normalize();
         Vec2 v = new Vec2(-u.y, u.x);
         Vec2 vc = u.scale(c);
         Vec2 vb = v.scale(b);

         if (nSols == 1)
            return new Vec2[]{center.add(vc).sub(vb)};
         return new Vec2[]{center.add(vc).add(vb), center.add(vc).sub(vb)};
      }
   }

   public moveaway_font(FastScanner in, PrintWriter out)
   {
      int n = in.nextInt();   
      Circle2[] friends = new Circle2[n];
      for (int i=0; i<n; i++)
      {
         Vec2 pos = new Vec2(in.nextInt(), in.nextInt());
         int rad = in.nextInt();
         friends[i] = new Circle2(pos, rad);
      }

      // Optimal solution will either be at the intersection of two circles or
      // the furthest point on a circle from the origin.
      //
      // Has a tricky special case when the circle is at the origin.
      ArrayDeque<Vec2> candidates = new ArrayDeque<>();
      for (int i=0; i<n; i++)
      {
         // Add all intersection candidates.
         for (int j=i+1; j<n; j++)
         {
            Vec2[] matches = friends[i].intersect(friends[j]);
            for (Vec2 v : matches)
               candidates.add(v);
         }

         // Tricky special case.
         // Circle is at the origin.
         // Extreme point can be a number of places (but all the same distance).
         // Or the extreme point is at some intersection.
         // Resolved by trying all points between intersection angles.
         if (friends[i].center.x == 0 && friends[i].center.y == 0)
         {
            candidates.add(new Vec2(friends[i].radius, 0)); 
         }
         else
         {
            // Furthest point on this circle may be the answer.
            Vec2 dv = friends[i].center.normalize(); 
            double len = friends[i].center.mag() + friends[i].radius;

            Vec2 pos = dv.scale(len);
            candidates.add(pos);
         }
      }

      // Check all the normal candidates.
      double res = -1;
      for (Vec2 pos : candidates)
      {
         boolean isOk = true;
         for (Circle2 f : friends)
            if (!f.contains(pos))
               isOk = false;
      
         if (isOk)
            res = Math.max(res, pos.mag());
      }

      // Check the smallest circle at the origin. Does it work?

      if (res == -1)
         out.printf("BAD DATA!!!%n");
      out.printf("%.3f%n", res+Geom.EPS);
   }
}

class Geom
{
   static double EPS = 1e-9;

   static boolean eq(double a, double b)
   {
      double d = Math.abs(a-b);
      if (d < EPS)
         return true;

      return d < EPS * Math.max(Math.abs(a), Math.abs(b));
   }

   static int testTriangle(double a, double b, double c)
   {
      double[] tri = new double[]{a, b, c};
      Arrays.sort(tri);
      double smallSides = tri[0] + tri[1];

      // Check degenerate case.
      if (eq(smallSides, tri[2]))
         return 1;
      if (smallSides > tri[2])
         return 2;
      return 0;
   }
}

class FastScanner{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    
    public FastScanner(InputStream stream)
    {
        this.stream = stream;
    }
    
    int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars){
            curChar = 0;
            try{
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    
    boolean isSpaceChar(int c)
    {
        return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
    }
    
    boolean isEndline(int c)
    {
        return c=='\n'||c=='\r'||c==-1;
    }
    
    int nextInt()
    {
        return Integer.parseInt(next());
    }
    
    long nextLong()
    {
        return Long.parseLong(next());
    }
    
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
    
    String next(){
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isSpaceChar(c));
        return res.toString();
    }
    
    String nextLine(){
        int c = read();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isEndline(c));
        return res.toString();
    }
}