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:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

import static java.lang.Math.*;
import static java.lang.String.format;

public class CF002C {
    private static class Point {
        double x;
        double y;

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

    private static class Circle extends Point {
        double r;

        public Circle(double x, double y, double r) {
            super(x, y);
            this.r = r;
        }
    }

    private static Point[] getCircleCircleIntersections(
            double cx0, double cy0, double radius0,
            double cx1, double cy1, double radius1) {
        double dx = cx0 - cx1;
        double dy = cy0 - cy1;
        double dist = sqrt(dx * dx + dy * dy); // Find the distance between the centers.
        if (dist > radius0 + radius1) {
            return new Point[]{}; // No solutions, the circles are too far apart.
        } else if (dist < abs(radius0 - radius1)) {
            return new Point[]{}; // No solutions, one circle contains the other.
        } else if ((dist == 0) && (radius0 == radius1)) {
            return new Point[]{}; // No solutions, the circles coincide.
        } else {
            // Find a and h.
            double a = (radius0 * radius0 - radius1 * radius1 + dist * dist) / (2 * dist);
            double h = sqrt(radius0 * radius0 - a * a);
            // Find P2.
            double cx2 = cx0 + a * (cx1 - cx0) / dist;
            double cy2 = cy0 + a * (cy1 - cy0) / dist;
            return new Point[]{
                    new Point(cx2 + h * (cy1 - cy0) / dist, cy2 - h * (cx1 - cx0) / dist),
                    new Point(cx2 - h * (cy1 - cy0) / dist, cy2 + h * (cx1 - cx0) / dist)
            };
        }
    }

    private static Point[] getLineCircleIntersections(
            double cx, double cy, double radius,
            Point point1, Point point2) {

        double dx = point2.x - point1.x;
        double dy = point2.y - point1.y;

        double A = dx * dx + dy * dy;
        double B = 2 * (dx * (point1.x - cx) + dy * (point1.y - cy));
        double C = (point1.x - cx) * (point1.x - cx) + (point1.y - cy) * (point1.y - cy) - radius * radius;

        double det = B * B - 4 * A * C;
        if ((A <= 0.0000001) || (det < 0)) {
            return new Point[]{}; // No real solutions.
        } else {
            // Two solutions.
            double t = (-B + sqrt(det)) / (2 * A);
            Point intersection1 = new Point(point1.x + t * dx, point1.y + t * dy);
            t = (-B - sqrt(det)) / (2 * A);
            Point intersection2 = new Point(point1.x + t * dx, point1.y + t * dy);
            return new Point[]{intersection1, intersection2};
        }
    }

    private static Point getLinesIntersection(Point p1, Point p2, Point p3, Point p4) {
        double dx12 = p2.x - p1.x;
        double dy12 = p2.y - p1.y;
        double dx34 = p4.x - p3.x;
        double dy34 = p4.y - p3.y;

        double t1 = ((p1.x - p3.x) * dy34 + (p3.y - p1.y) * dx34) / (dy12 * dx34 - dx12 * dy34);
        if (Double.isInfinite(t1)) {
            return null;
        }
        return new Point(p1.x + dx12 * t1, p1.y + dy12 * t1);
    }

    private static Point getPerpendicularVector(Point v) {
        return new Point(-v.y, v.x);
    }

    private static Point getMiddle(Point a, Point b) {
        return new Point(a.x + 0.5 * (b.x - a.x), a.y + 0.5 * (b.y - a.y));
    }

    private static Point[] getBisect(Point a, Point b) {
        Point lp1 = getMiddle(a, b);
        Point perpend1 = getPerpendicularVector(new Point(b.x - a.x, b.y - a.y));
        Point lp2 = new Point(lp1.x + perpend1.x, lp1.y + perpend1.y);
        return new Point[]{lp1, lp2};
    }

    private static Circle getSameAngle(Circle p1, Circle p2) {
        double RS1 = p1.r * p1.r;
        double RS2 = p2.r * p2.r;
        double t = (RS2 * p1.x - RS1 * p2.x) / (RS2 - RS1);
        double u = (RS2 * p1.y - RS1 * p2.y) / (RS2 - RS1);
        double RS = (RS1 * p2.x * p2.x - RS2 * p1.x * p1.x)/ (RS2 - RS1) +
                (RS1 * p2.y * p2.y - RS2 * p1.y * p1.y)/ (RS2 - RS1) +
                t*t + u*u;
        return new Circle(t, u, sqrt(RS));
    }

    private static double dist(Point a, Point b) {
        return sqrt(pow(a.x-b.x, 2) + pow(a.y-b.y, 2));
    }

    private static Point closest(Point[] ps, Point p) {
        double minDist = dist(ps[0], p);
        Point closest = ps[0];
        for (int i = 1; i < ps.length; i++) {
            double dist = dist(ps[i], p);
            if (minDist > dist) {
                minDist = dist;
                closest = ps[i];
            }
        }
        return closest;
    }

    private static Point solveForTwoLines(Circle p1, Circle p2, Circle p3) {
        Point[] segment1 = getBisect(p1, p2);
        Point[] segment2 = getBisect(p2, p3);
        return getLinesIntersection(segment1[0], segment1[1], segment2[0], segment2[1]);
    }

    private static Point solveForLineAndCircle(Circle p1, Circle p2, Circle p3) {
        Point[] segment = getBisect(p1, p2);
        Circle c = getSameAngle(p2, p3);
        Point[] inters = getLineCircleIntersections(c.x, c.y, c.r, segment[0], segment[1]);
        if (inters.length == 0) return null;
        return closest(inters, p1);
    }

    private static Point solveForTwoCircles(Circle p1, Circle p2, Circle p3) {
        Circle c1 = getSameAngle(p1, p2);
        Circle c2 = getSameAngle(p2, p3);
        Point[] inters = getCircleCircleIntersections(c1.x, c1.y, c1.r, c2.x, c2.y, c2.r);
        if (inters.length == 0) return null;
        return closest(inters, p1);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        Circle p1 = new Circle(scanner.nextInt(), scanner.nextInt(), scanner.nextInt());
        Circle p2 = new Circle(scanner.nextInt(), scanner.nextInt(), scanner.nextInt());
        Circle p3 = new Circle(scanner.nextInt(), scanner.nextInt(), scanner.nextInt());

        Point intersect;
        if (p1.r == p2.r && p2.r == p3.r) {
            intersect = solveForTwoLines(p1, p2, p3);
        } else if (p1.r == p2.r) {
            intersect = solveForLineAndCircle(p1, p2, p3);
        } else if (p1.r == p3.r){
            intersect = solveForLineAndCircle(p1, p3, p2);
        } else if (p2.r == p3.r){
            intersect = solveForLineAndCircle(p2, p3, p1);
        } else {
            intersect = solveForTwoCircles(p1, p2, p3);
        }
        if (intersect == null) return;
        System.out.println(format("%.5f %.5f", intersect.x, intersect.y));
    }
}