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.util.Scanner;

public class Main {

    public static double EPS = 0.000001;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Circle stad1 = new Circle(sc.nextInt(), sc.nextInt(), sc.nextInt());
        Circle stad2 = new Circle(sc.nextInt(), sc.nextInt(), sc.nextInt());
        Circle stad3 = new Circle(sc.nextInt(), sc.nextInt(), sc.nextInt());

        if (stad1.radius > stad2.radius) {
            Circle temp = stad1;
            stad1 = stad2;
            stad2 = temp;
        }
        if (stad1.radius > stad3.radius) {
            Circle temp = stad1;
            stad1 = stad3;
            stad3 = temp;
        }

        Line side12 = new Line(stad1.center.x, stad1.center.y, stad2.center.x,
                        stad2.center.y);
        Line side13 = new Line(stad3.center.x, stad3.center.y, stad1.center.x,
                        stad1.center.y);

        Shape shape12 = null;
        if (stad1.radius == stad2.radius) {
            shape12 = side12.perpendicular(new Point(
                            (stad1.center.x + stad2.center.x) / 2,
                            (stad1.center.y + stad2.center.y) / 2));
        }
        else {
            double dx = stad2.center.x - stad1.center.x;
            double dy = stad2.center.y - stad1.center.y;
            double p1x = stad1.center.x + dx * stad1.radius
                            / (stad1.radius + stad2.radius);
            double p1y = stad1.center.y + dy * stad1.radius
                            / (stad1.radius + stad2.radius);
            double p2x = stad1.center.x - dx * stad1.radius
                            / (stad2.radius - stad1.radius);
            double p2y = stad1.center.y - dy * stad1.radius
                            / (stad2.radius - stad1.radius);
            double r = Math.sqrt((p2x - p1x) * (p2x - p1x) + (p2y - p1y)
                            * (p2y - p1y)) / 2;
            shape12 = new Circle((p1x + p2x) / 2, (p1y + p2y) / 2, r);
        }

        Shape shape13 = null;
        if (stad1.radius == stad3.radius) {
            shape13 = side13.perpendicular(new Point(
                            (stad1.center.x + stad3.center.x) / 2,
                            (stad1.center.y + stad3.center.y) / 2));
        }
        else {
            double dx = stad3.center.x - stad1.center.x;
            double dy = stad3.center.y - stad1.center.y;
            double p1x = stad1.center.x + dx * stad1.radius
                            / (stad1.radius + stad3.radius);
            double p1y = stad1.center.y + dy * stad1.radius
                            / (stad1.radius + stad3.radius);
            double p2x = stad1.center.x - dx * stad1.radius
                            / (stad3.radius - stad1.radius);
            double p2y = stad1.center.y - dy * stad1.radius
                            / (stad3.radius - stad1.radius);
            double r = Math.sqrt((p2x - p1x) * (p2x - p1x) + (p2y - p1y)
                            * (p2y - p1y)) / 2;
            shape13 = new Circle((p1x + p2x) / 2, (p1y + p2y) / 2, r);
        }

        Point[] res = shape12.intersect(shape13);
        if (res == null) {
            return;
        }

        if (res.length == 1) {
            System.out.println(res[0]);
        }
        if (res.length == 2) {
            if (res[0].distTo(stad1.center) < res[1].distTo(stad1.center)) {
                System.out.println(res[0]);
            }
            else {
                System.out.println(res[1]);
            }
        }
    }

    static abstract class Shape {

        public abstract Point[] intersect(Shape otherShape);
    }

    static class Line extends Shape {

        final double A;
        final double B;
        final double C;

        Line(double A, double B, double C) {
            this.A = A;
            this.B = B;
            this.C = C;
        }

        Line(double x1, double y1, double x2, double y2) {
            A = y1 - y2;
            B = x2 - x1;
            C = x1 * y2 - x2 * y1;
        }

        Line perpendicular(Point p) {
            return new Line(-B, A, B * p.x - A * p.y);
        }

        @Override
        public String toString() {
            return String.format("%.2fx+%.2fy+%.2f = 0", A, B, C);
        }

        @Override
        public Point[] intersect(Shape otherShape) {
            if (otherShape instanceof Line) {
                Point p = intersectOtherLine((Line) otherShape);
                if (p == null) {
                    return null;
                }
                return new Point[] { p };
            }
            if (otherShape instanceof Circle) {
                return intersectCircle((Circle) otherShape);
            }
            return null;
        }

        public Point intersectOtherLine(Line otherLine) {
            double d = A * otherLine.B - B * otherLine.A;
            if (d == 0) {
                return null;
            }
            return new Point((B * otherLine.C - C * otherLine.B) / d, (C
                            * otherLine.A - A * otherLine.C)
                            / d);
        }

        public Point[] intersectCircle(Circle circle) {
            Line line1 = perpendicular(circle.center);
            Point point1 = intersectOtherLine(line1);
            double d = circle.center.distTo(point1);
            if (Math.abs(d - circle.radius) < EPS) {
                return new Point[] { point1 };
            }
            if (d > circle.radius) {
                return null;
            }
            double m = Math.sqrt(circle.radius * circle.radius - d * d);
            double dx = B;
            double dy = -A;
            dx = dx / Math.sqrt(A * A + B * B);
            dy = dy / Math.sqrt(A * A + B * B);
            dx = dx * m;
            dy = dy * m;
            Point p1 = new Point(point1.x + dx, point1.y + dy);
            Point p2 = new Point(point1.x - dx, point1.y - dy);
            return new Point[] { p1, p2 };
        }
    }

    static class Circle extends Shape {

        final Point center;
        final double radius;

        Circle(double centerX, double centerY, double radius) {
            center = new Point(centerX, centerY);
            this.radius = radius;
        }

        @Override
        public String toString() {
            return String.format("(%.2f, %.2f) : %.2f", center.x, center.y,
                            radius);
        }

        @Override
        public Point[] intersect(Shape otherShape) {
            if (otherShape instanceof Line) {
                return otherShape.intersect(this);
            }
            if (otherShape instanceof Circle) {
                Circle circle = (Circle) otherShape;
                double d = center.distTo(circle.center);
                if (d - radius - circle.radius > EPS) {
                    return null;
                }
                if (Math.abs(radius - circle.radius) - d > EPS) {
                    return null;
                }
                double A = (circle.center.x - center.x) * 2;
                double B = (circle.center.y - center.y) * 2;
                double C = (center.x * center.x - circle.center.x
                                * circle.center.x)
                                + (center.y * center.y - circle.center.y
                                                * circle.center.y)
                                - (radius * radius - circle.radius
                                                * circle.radius);

                return new Line(A, B, C).intersectCircle(this);
            }
            return null;
        }
    }

    static class Point {

        final double x;
        final double y;

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

        double distTo(Point p) {
            return Math.sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
        }

        @Override
        public String toString() {
            String str = String.format("%.5f %.5f", x, y);
            return str.replaceAll("-0\\.00000", "0\\.00000");
        }
    }
}