import java.awt.geom.Point2D;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * Solution to SMove Away
 * 
 * @author vanb
 */
public class moveaway_vanb
{
    private static Scanner sc;
    private static PrintStream ps;
    
    private static final double EPSILON = 0.000001;
    
    /**
     * Info about a Friend - location, and distance.
     * 
     * @author vanb
     */
    private class Friend
    {
        /** Location */
        double x, y;
        
        /** Distance */
        double d;
        
        /**
         * Create a Friend.
         * 
         * @param x X coord of location
         * @param y Y coord of location
         * @param d Distance
         */
        public Friend( double x, double y, double d )
        {
            this.x = x;
            this.y = y;
            this.d = d;
        }
    }
    
    /**
     * Law of Cosines! EXTREMELY useful.
     * 
     * The LoC says that for any triangle, if a, b, and c are its side lengths,
     * and theta is the angle between a and b (opposite c), then:
     * 
     * c^2 = a^2 + b^2 -2*a*b*cos(theta)
     * 
     * Solve for theta, and we get cos(theta) = (a^2+b^2-c^2)/(2*a*b),
     * or theta = arccos[(a^2+b^2-c^2)/(2*a*b)]
     * 
     * @param a Leg of a triangle adjacent to theta
     * @param b The other leg of a triangle adjacent to theta
     * @param c Leg of a triangle opposite theta
     * @return theta
     */
    private double loc( double a, double b, double c )
    {
        return Math.acos( (a*a+b*b-c*c)/(2.0*a*b) );
    }
    
    /**
     * Do it!
     */
    private void doit()
    {
        int n = sc.nextInt();
        
        Friend friends[] = new Friend[n];
        for( int i=0; i<n; i++ )
        {
            double x = sc.nextDouble();
            double y = sc.nextDouble();
            double d = sc.nextDouble();
            friends[i] = new Friend( x, y, d );
        }
        
        // We'll create a list of Candidates, and then work through them to see which is best.
        List<Point2D.Double> candidates = new ArrayList<Point2D.Double> (2*n*n);
        
        // Thinks of a circle, and an arbitraty point on that circle.
        // Move away from the origin along the edge. What's going to stop you from getting
        // further away from the origin? Two things: either the furthest point on the circle from the origin,
        // or an intersection with another circle.
        for( int i=0; i<friends.length; i++ )
        {
            // The furthest point from the origin to the circle is a candidate
            double angle = Math.atan2( friends[i].y, friends[i].x );
            double distance = Math.hypot( friends[i].y, friends[i].x ) + friends[i].d;
            candidates.add( new Point2D.Double( distance*Math.cos( angle ), distance*Math.sin( angle ) ) );
            
            // The intersections of this circle with other circles are also candidates.
            for( int j=i+1; j<n; j++ )
            {
                // Think of a triangle with vertices at the center of the two circles and at a point of intersection.
                // We can easily find the lengths of all 3 of the legs (radius of the two circles and the distance 
                // between their centers). We can then use the Law of Cosines to find the angle between the
                // line segment from our center to the other center, and the line segment from our center to
                // the intersection point.
                
                // Angle from our center to the other center
                double cangle = Math.atan2( friends[j].y-friends[i].y, friends[j].x-friends[i].x );
                
                // Distance from our center to the other center
                double cdist = Math.hypot( friends[j].y-friends[i].y, friends[j].x-friends[i].x );
                
                // Inner angle - the angle between the line between the centers and the line from
                // or center to the intersection point
                double inner = loc( friends[i].d, cdist, friends[j].d );
                
                // Now, we can find the two intersection points.
                candidates.add( new Point2D.Double( friends[i].x + friends[i].d*Math.cos( cangle-inner ), friends[i].y + friends[i].d*Math.sin( cangle-inner ) ) );
                candidates.add( new Point2D.Double( friends[i].x + friends[i].d*Math.cos( cangle+inner ), friends[i].y + friends[i].d*Math.sin( cangle+inner ) ) );                
            }
        }
        
        // OK, now go through all of the candidates, check to see if each candidate is inside of all circles.
        // If it is, then check its distance to the origin (i.e. parent's house) and find the max.
        double maxdist = 0.0;
        for( Point2D.Double candidate : candidates )
        {
            boolean insideall = true;
            for( Friend friend : friends )
            {
                // Check to see if the distance from the center to the candidate is less than or equal to the radius.
                double dist = Math.hypot( friend.y-candidate.y, friend.x-candidate.x );
                if( dist>friend.d + EPSILON ) 
                {
                    insideall = false;
                    break;
                }
            }
            
            // Inside all circles? Check the distance to the origin.
            if( insideall )
            {
                double dist = Math.hypot( candidate.y, candidate.x );
                if( dist>maxdist ) maxdist = dist;
            }
        }
        
        ps.printf( "%.3f", maxdist );
        ps.println();
    }
        
    /**
     * Main!
     * 
     * @param args Command-line args (not used)
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        new moveaway_vanb().doit();
    }

}