Problem: The Olympic Games in Bercouver are in full swing now. Here everyone has their own objectives: sportsmen compete for medals, and sport commentators compete for more convenient positions to give a running commentary. Today the main sport events take place at three round stadiums, and the commentator's objective is to choose the best point of observation, that is to say the point from where all the three stadiums can be observed. As all the sport competitions are of the same importance, the stadiums should be observed at the same angle. If the number of points meeting the conditions is more than one, the point with the maximum angle of observation is prefered. 

Would you, please, help the famous Berland commentator G. Berniev to find the best point of observation. It should be noted, that the stadiums do not hide each other, the commentator can easily see one stadium through the other.

Input

The input data consists of three lines, each of them describes the position of one stadium. The lines have the format x, y, r, where (x, y) are the coordinates of the stadium's center ( - 103 ≤ x, y ≤ 103), and r (1 ≤ r ≤ 103) is its radius. All the numbers in the input data are integer, stadiums do not have common points, and their centers are not on the same line. 

Output

Print the coordinates of the required point with five digits after the decimal point. If there is no answer meeting the conditions, the program shouldn't print anything. The output data should be left blank.

Examples

Input

0 0 10
60 0 10
30 30 10


Output

30.00000 0.00000

Solution (in JAVA):

Solution:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.Locale;
import java.util.Scanner;

/**
 *
 * @author Danek
 */
public class Task2C {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        String[] numbers;
        Double[] s1 = new Double[3];
        Double[] s2 = new Double[3];
        Double[] s3 = new Double[3];
        Integer a = 5;
        Scanner input = new Scanner(System.in);
        s1[0] = input.nextDouble();
        s1[1] = input.nextDouble();
        s1[2] = input.nextDouble();

        s2[0] = input.nextDouble();
        s2[1] = input.nextDouble();
        s2[2] = input.nextDouble();

        s3[0] = input.nextDouble();
        s3[1] = input.nextDouble();
        s3[2] = input.nextDouble();

        Double[] l12 = calculateLocus(s1, s2);
        Double[] l23 = calculateLocus(s2, s3);

        Double xa;
        Double ya;

        if (l12[0].equals(0.0) && l23[0].equals(0.0)) {
            xa = -(l12[3] * l23[2] - l23[3] * l12[2]) / (l12[1] * l23[2] - l23[1] * l12[2]);
            ya = -(l12[1] * l23[3] - l23[1] * l12[3]) / (l12[1] * l23[2] - l23[1] * l12[2]);
        } else {
            Double[] buffer;
            Double xs = 0.0;
            Double ys = 0.0;

            if (l12[0].equals(1.0) && l23[0].equals(1.0)) {
                buffer = new Double[4];

                // Shift dimensions
                xs += l12[1];
                ys += l12[2];

                // Perform the shift
                l12[1] -= xs;
                l23[1] -= xs;
                l12[2] -= ys;
                l23[2] -= ys;

                // Now l12 has center at the 0, 0 point; Let's turn l23 into the line
                buffer[0] = 0.0;
                buffer[1] = -2 * l23[1];
                buffer[2] = -2 * l23[2];
                buffer[3] = l23[1] * l23[1] + l23[2] * l23[2] + l12[3] * l12[3] - l23[3] * l23[3];

                l23 = buffer;
            } else if (l12[0].equals(0.0) && l23[0].equals(1.0)) {
                buffer = l12;
                l12 = l23;
                l23 = buffer;
            }

            // Now l12 is a circle and l23 is a line. Calculate the answer! :)
            l23[3] += l23[1] * l12[1] + l23[2] * l12[2];
            xs += l12[1];
            l12[1] = 0.0;
            ys += l12[2];
            l12[2] = 0.0;

            Double x0 = -(l23[1] * l23[3]) / (l23[1] * l23[1] + l23[2] * l23[2]);
            Double y0 = -(l23[2] * l23[3]) / (l23[1] * l23[1] + l23[2] * l23[2]);
            Double d = Math.sqrt(l12[3] * l12[3] - l23[3] * l23[3] / (l23[1] * l23[1] + l23[2] * l23[2]));
            Double mult = Math.sqrt(d * d / (l23[1] * l23[1] + l23[2] * l23[2]));
            Double ax = x0 + l23[2] * mult;
            Double ay = y0 - l23[1] * mult;
            Double bx = x0 - l23[2] * mult;
            Double by = y0 + l23[1] * mult;
            Double da = Math.sqrt(Math.pow(s1[0] - ax - xs, 2.0) + Math.pow(s1[1] - ay - ys, 2.0));
            Double db = Math.sqrt(Math.pow(s1[0] - bx - xs, 2.0) + Math.pow(s1[1] - by - ys, 2.0));
            if (da < db) {
                xa = ax;
                ya = ay;
            } else {
                xa = bx;
                ya = by;
            }
            xa += xs;
            ya += ys;
        }

        if (xa.equals(-0.0)) {
            xa = 0.0;
        }
        if (ya.equals(-0.0)) {
            ya = 0.0;
        }

        if (!xa.equals(Double.NaN) && !ya.equals(Double.NaN)) {
            System.out.format(Locale.US, "%.5f %.5f", xa, ya);
        }
    }

    static Double[] calculateLocus(Double[] s1, Double[] s2) {
        Double[] answer;
        Double kc1 = s1[2] / (s1[2] + s2[2]); // koefficent for r1
        Double xc1 = s1[0] + (s2[0] - s1[0]) * kc1;
        Double yc1 = s1[1] + (s2[1] - s1[1]) * kc1;
        if (kc1.equals(0.5)) {
            // line case => line parameters are calculated below
            Double lA;
            Double lB;
            Double lC;

            lA = s1[0] - s2[0];
            lB = s1[1] - s2[1];
            lC = -lA * xc1 - lB * yc1;

            answer = new Double[]{0.0, lA, lB, lC};
        } else {
            // circle case => circle parameters are calculated below
            Double kc2 = s1[2] / (s1[2] - s2[2]); // second koefficent for r1
            Double xc2 = s1[0] + (s2[0] - s1[0]) * kc2;
            Double yc2 = s1[1] + (s2[1] - s1[1]) * kc2;
            Double xc0 = (xc1 + xc2) / 2.0;
            Double yc0 = (yc1 + yc2) / 2.0;
            Double r = Math.sqrt(Math.pow(xc2 - xc1, 2.0) + Math.pow(yc2 - yc1, 2.0)) / 2.0;
            answer = new Double[]{1.0, xc0, yc0, r};
        }

        return answer;
    }
}