import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Gears
 * 
 * @author vanb
 */
public class gears_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * This is a "Move" in the breadth-first search.
     * @author vanb
     */
    public class Move
    {
        /** The gear we're moving to */
        public int gear;
        
        /** 
         * The direction it should be spinning:
         *  1 = same direction as the source gear
         * -1 = opposite direction from the source gear
         *  0 = We haven't reached this gear from the source gear
         */
        public int direction;
        
        /**
         * Build a Move.
         * 
         * @param gear Gear number
         * @param direction Direction it's spinning
         */
        public Move( int gear, int direction )
        {
            this.gear = gear;
            this.direction = direction;
        }
    }
    
    /**
     * This holds all of the pertinent info for a gear.
     * 
     * @author vanb
     */
    public class Gear
    {
        /** x,y coordinates */
        public int x, y;
        
        /** Radius */
        public int r;
        
        /** Direction it's spinning (See 'Move' above) */
        public int direction;
        
        /** Other gears it meshes with */
        public LinkedList<Integer> edges = new LinkedList<Integer>();
        
        /**
         * Build a Gear.
         * 
         * @param x X coord of center
         * @param y Y coord of center
         * @param r Radius
         */
        public Gear( int x, int y, int r )
        {
            this.x = x;
            this.y = y;
            this.r = r;
            this.direction = 0;
        }
    }
    
    /**
     * Greatest common Divisor, using Euler's technique.
     * 
     * @param a An integer
     * @param b Another integer
     * @return The Greatest Common Divisor of a and b
     */
    public int gcd( int a, int b )
    {
        return b==0 ? a : gcd( b, a%b );
    }
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        int n = sc.nextInt();
        Gear gears[] = new Gear[n];
        
        for( int i=0; i<n; i++ )
        {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int r = sc.nextInt();
            
            gears[i] = new Gear( x, y, r );
            
            // Find out which gears mesh with this one, and form a graph.
            for( int j=0; j<i; j++ )
            {
                // If the distance between centers is equal to the sum of radii,
                // then the gears mesh. To keep things in integers, we'll
                // compare distance^2 instead of distance.
                long dx = gears[j].x - x;
                long dy = gears[j].y - y;
                long sr = gears[j].r + r;
                if( dx*dx + dy*dy == sr*sr )
                {
                    gears[i].edges.add( j );
                    gears[j].edges.add( i );
                }
            }
        }
        
        // Can the source gear turn freely?
        boolean free = true;
        
        // We'll use BFS to analyze the graph, to see if:
        // 1) any gear has to turn in both directions (meaning the system will not turn at all)
        // 2) If the source gear can turn the target gear
        LinkedList<Move> q = new LinkedList<Move>();
        q.add( new Move( 0, 1 ) );
        while( free && !q.isEmpty() )
        {
            Move m = q.removeFirst();
            
            // If we haven't visited this gear yet, then
            // set its direction and go to its neighbors.
            if( gears[m.gear].direction==0 )
            {
                gears[m.gear].direction = m.direction;
                for( int i : gears[m.gear].edges )
                {
                    q.add( new Move( i, -m.direction ) );
                }
            }
            else 
            {
                // If we have visited it, make sure
                // it's turning in the right direction.
                free = gears[m.gear].direction == m.direction;
            }
        }
        
        // If free is false, then the source gear cannot turn freely.
        if( !free ) ps.println( -1 );
        // If the target gear's direction hasn't been set, then we can't reach it.
        else if( gears[n-1].direction==0 ) ps.println( 0 );
        else
        {
            // Otherwise, the turning ratio is just based on the radii.
            int factor = gcd( gears[0].r, gears[n-1].r );
            int a = gears[n-1].r / factor;
            int b = gears[0].r / factor * gears[n-1].direction;
            ps.println( a + " " + b );
        }
        
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new gears_vanb().doit();        
    }   
}