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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class L implements Runnable {
    static String hack = "public class X ";

    static final double EPS = 1e-5;

    public static void main(String[] args) {
        new Thread(new L()).start();
    }

    public void run() {
        try {
            solve();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    BufferedReader br;
    StringTokenizer st = new StringTokenizer("");

    static class Point {
        final double x, y;

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

        @Override
        public String toString() {
            return "(" + x + ", " + y + ")";
        }
    }

    static abstract class Shape {

    }

    static class Line extends Shape {
        final Point p;
        final Point v;

        Line(Point p, Point v) {
            this.p = p;
            this.v = v;
        }

    }

    static class Circle extends Shape {
        final Point c;
        final double r;

        Circle(Point c, double r) {
            this.c = c;
            this.r = r;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "c=" + c +
                    ", r=" + r +
                    '}';
        }
    }

    void solve() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        Circle c1 = nextCircle();
        Circle c2 = nextCircle();
        Circle c3 = nextCircle();
        br.close();

        Shape s12 = equiliblirium(c1, c2);
        Shape s13 = equiliblirium(c1, c3);
        Point[] commonPoints = intersect(s12, s13);
        double leastDistPow2 = Double.MAX_VALUE;
        Point ans = null;
        for (Point commonPoint : commonPoints) {
            double currDistPow2 = dist2(commonPoint, c1.c);
            if (currDistPow2 < leastDistPow2) {
                leastDistPow2 = currDistPow2;
                ans = commonPoint;
            }
        }
        PrintWriter pw = new PrintWriter(System.out);
        if (ans != null) {
            pw.printf("%.5f %.5f\n", ans.x, ans.y);
        }
        pw.close();
    }

    Point[] intersect(Shape s1, Shape s2) {
        if (s1 instanceof Line && s2 instanceof Line) {
            return intersectLineLine((Line) s1, (Line) s2);
        }
        if (s1 instanceof Circle && s2 instanceof Circle) {
            return intersectCircleCircle((Circle) s1, (Circle) s2);
        }
        if (s1 instanceof Circle) {
            return intersectCircleLine((Circle) s1, (Line) s2);
        } else {
            return intersectCircleLine((Circle) s2, (Line) s1);
        }
    }

    Point[] intersectCircleLine(Circle circle, Line line) {
        Point[] ii = intersectLineLine(line, new Line(circle.c, rotate90Clockwise(line.v)));
        Point ip = ii[0];
        double d2 = dist2(circle.c, ip);
        if (pow2(circle.r) + EPS < d2) {
            return new Point[] {};
        }
        double up = Math.sqrt(Math.abs(pow2(circle.r) - d2));
        Point v = resize(line.v, up);
        return new Point[] {
                add(ip, v),
                add(ip, multiply(v, -1))
        };
    }

    Point[] intersectCircleCircle(Circle circle1, Circle circle2) {
        final Point c1 = circle1.c, c2 = circle2.c;
        final double r1 = circle1.r, r2 = circle2.r;
        final double l2 = dist2(c1, c2);
        final double l = Math.sqrt(l2);
        if (r1 + r2 + EPS < l) {
            return new Point[] {};
        }
        if (l + Math.min(r1, r2) + EPS < Math.max(r1, r2)) {
            return new Point[] {};
        }
        double l1 = (pow2(r1) - pow2(r2) + l2) / (2 * l);
        double up1 = Math.sqrt(Math.abs(pow2(r1) - pow2(l1)));
        Point v = normalize(v(c1, c2));
        Point q = add(c1, multiply(v, l1));
        Point vp = multiply(rotate90Clockwise(v), up1);
        return new Point[] {
                add(q, vp),
                add(q, multiply(vp, -1))
        };
    }

    Point[] intersectLineLine(Line line1, Line line2) {
        double det = det(
                line1.v.x, -line2.v.x,
                line1.v.y, -line2.v.y
        );
        if (Math.abs(det) < EPS) {
            return new Point[] {};
        }
        double t1 = det(
                line2.p.x - line1.p.x, -line2.v.x,
                line2.p.y - line1.p.y, -line2.v.y
        );
        t1 /= det;
        Point i = add(line1.p, multiply(line1.v, t1));
        return new Point[] {i};
    }

    Shape equiliblirium(Circle c1, Circle c2) {
        if (Math.abs(c1.r - c2.r) > 0.5) {
            return buildCenterCircle(c1, c2);
        }
        return buildCenterLine(c1, c2);
    }

    Shape buildCenterCircle(Circle c1, Circle c2) {
        double r1pow2 = pow2(c1.r), r2pow2 = pow2(c2.r);
        double x1 = c1.c.x, y1 = c1.c.y, x2 = c2.c.x, y2 = c2.c.y;
        double denom = r2pow2 - r1pow2;
        double ax = 2 * (x2 * r1pow2 - x1 * r2pow2) / denom;
        double ay = 2 * (y2 * r1pow2 - y1 * r2pow2) / denom;
        double a = (r1pow2 * (pow2(x2) + pow2(y2)) - r2pow2 * (pow2(x1) + pow2(y1))) / denom;
        double xi = -ax / 2;
        double yi = -ay / 2;
        double riPow2 = a + pow2(xi) + pow2(yi);
        if (riPow2 < EPS) {
            throw new RuntimeException("BOTVA");
        }
        double ri = Math.sqrt(riPow2);
        return new Circle(new Point(xi, yi), ri);
    }

    Line buildCenterLine(Circle c1, Circle c2) {
        Point v = v(c1.c, c2.c);
        Point center = multiply(add(c1.c, c2.c), 0.5);
        return new Line(center, rotate90Clockwise(v));
    }

    static double pow2(double x) {
        return x * x;
    }

    static double det(double a11, double a12, double a21, double a22) {
        return a11 * a22 - a12 * a21;
    }

    static Point v(Point from, Point to) {
        return new Point(to.x - from.x, to.y - from.y);
    }

    static Point add(Point p, Point v) {
        return new Point(p.x + v.x, p.y + v.y);
    }

    static Point multiply(Point v, double k) {
        return new Point(v.x * k, v.y * k);
    }

    static Point resize(Point v, double length) {
        return multiply(normalize(v), length);
    }

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

    static double dist(Point a, Point b) {
        return Math.sqrt(dist2(a, b));
    }

    static double dist2(Point a, Point b) {
        return pow2(a.x - b.x) + pow2(a.y - b.y);
    }

    static Point normalize(Point v) {
        double l = dist(new Point(0, 0), v);
        return new Point(v.x / l, v.y / l);
    }

    Circle nextCircle() throws IOException {
        int x = nextInt();
        int y = nextInt();
        int r = nextInt();
        return new Circle(new Point(x, y), r);
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

}