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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &s, pair<T1, T2> P) {
  return s << '<' << P.first << ", " << P.second << '>';
}
template <class T>
ostream &operator<<(ostream &s, vector<T> P) {
  s << "{ ";
  for (int i = 0; i < P.size(); ++i) {
    if (i > 0) s << ", ";
    s << P[i];
  }
  return s << " }" << endl;
}
template <class T1, class T2>
ostream &operator<<(ostream &s, map<T1, T2> P) {
  s << "{ ";
  for (typeof(P.begin()) it = P.begin(); it != P.end(); ++it) {
    if (it != P.begin()) s << ", ";
    s << '<' << it->first << "->" << it->second << '>';
  }
  return s << " }" << endl;
}
const double INF = 1e10;
const double EPS = 1e-9;
const double PI = acos(-1.0);
double torad(int deg) { return (double)(deg)*M_PI / 180; }
struct Point {
  double x, y;
  Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
  friend ostream &operator<<(ostream &s, const Point &p) {
    return s << '(' << p.x << ", " << p.y << ')';
  }
};
Point operator+(Point p, Point q) { return Point(p.x + q.x, p.y + q.y); }
Point operator-(Point p, Point q) { return Point(p.x - q.x, p.y - q.y); }
Point operator*(Point p, double a) { return Point(p.x * a, p.y * a); }
Point operator*(double a, Point p) { return Point(a * p.x, a * p.y); }
Point operator*(Point p, Point q) {
  return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);
}
Point operator/(Point p, double a) { return Point(p.x / a, p.y / a); }
Point rot(Point p, double ang) {
  return Point(cos(ang) * p.x - sin(ang) * p.y,
               sin(ang) * p.x + cos(ang) * p.y);
}
Point rot90(Point p) { return Point(-p.y, p.x); }
double cross(Point p, Point q) { return p.x * q.y - p.y * q.x; }
double dot(Point p, Point q) { return p.x * q.x + p.y * q.y; }
double norm(Point p) { return dot(p, p); }
double abs(Point p) { return sqrt(dot(p, p)); }
bool eq(Point p, Point q) { return abs(p - q) < EPS; }
struct Line : vector<Point> {
  Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
    this->push_back(a);
    this->push_back(b);
  }
};
struct Line_Equation {
  double a, b, c;
  Line_Equation(double a = 1.0, double b = 1.0, double c = 0.0)
      : a(a), b(b), c(c) {}
  friend ostream &operator<<(ostream &s, const Line_Equation &l) {
    return s << l.a << "x + " << l.b << "y + " << l.c << " = 0";
  }
};
struct Circle : Point {
  double r;
  Circle(Point p = Point(0.0, 0.0), double r = 0.0) : Point(p), r(r) {}
  friend ostream &operator<<(ostream &s, const Circle &e) {
    return s << "((" << e.x << ", " << e.y << "), " << e.r << ')';
  }
};
Point proj(Point p, Line l) {
  double t = dot(p - l[0], l[1] - l[0]) / norm(l[1] - l[0]);
  return l[0] + (l[1] - l[0]) * t;
}
double distance(Point p, Line l) { return abs(p - proj(p, l)); }
vector<Point> crosspoint(Line l, Line m) {
  vector<Point> res;
  double d = cross(m[1] - m[0], l[1] - l[0]);
  if (abs(d) < EPS) return vector<Point>();
  res.push_back(l[0] + (l[1] - l[0]) * cross(m[1] - m[0], m[1] - l[0]) / d);
  return res;
}
vector<Point> crosspoint(Circle e, Circle f) {
  vector<Point> res;
  double d = abs(e - f);
  if (d < EPS) return vector<Point>();
  double rcos = (d * d + e.r * e.r - f.r * f.r) / (2.0 * d);
  double rsin = sqrt(e.r * e.r - rcos * rcos);
  Point dir = (f - e) / d;
  Point p1 = e + dir * Point(rcos, rsin);
  Point p2 = e + dir * Point(rcos, -rsin);
  res.push_back(p1);
  if (!eq(p1, p2)) res.push_back(p2);
  return res;
}
vector<Point> crosspoint(Circle e, Line l) {
  vector<Point> res;
  Point p = proj(e, l);
  double rcos = abs(e - p);
  if (rcos > e.r + EPS) return vector<Point>();
  double rsin = sqrt(e.r * e.r - rcos * rcos);
  Point dir = (l[1] - l[0]) / abs(l[1] - l[0]);
  Point p1 = p + dir * rsin;
  Point p2 = p - dir * rsin;
  res.push_back(p1);
  if (!eq(p1, p2)) res.push_back(p2);
  return res;
}
Line_Equation konjiku(Circle e, Circle f) {
  return Line_Equation((e.x - f.x) * 2.0, (e.y - f.y) * 2.0,
                       (e.r * e.r - e.x * e.x - e.y * e.y) -
                           (f.r * f.r - f.x * f.x - f.y * f.y));
}
int main() {
  Point res;
  Point a, b, c;
  int ra, rb, rc;
  while (cin >> a.x >> a.y >> ra >> b.x >> b.y >> rb >> c.x >> c.y >> rc) {
    vector<Point> alt;
    if (ra == rb && ra == rc) {
      Point mid1 = (a + b) / 2;
      Point dir1 = rot90(b - a);
      Line l1(mid1, mid1 + dir1);
      Point mid2 = (a + c) / 2;
      Point dir2 = rot90(c - a);
      Line l2(mid2, mid2 + dir2);
      alt = crosspoint(l1, l2);
    } else if (ra == rb || ra == rc) {
      if (ra == rc) {
        swap(b, c);
        swap(rb, rc);
      }
      Point mid1 = (a + b) / 2;
      Point dir1 = rot90(b - a);
      Line l1(mid1, mid1 + dir1);
      Point ica = (c * ra + a * rc) / (rc + ra);
      Point eca = (c * ra - a * rc) / (-rc + ra);
      Point cen2 = (ica + eca) / 2;
      double rad2 = abs(ica - eca) / 2;
      Circle c2(cen2, rad2);
      alt = crosspoint(c2, l1);
    } else {
      Point iab = (a * rb + b * ra) / (ra + rb);
      Point eab = (a * rb - b * ra) / (-ra + rb);
      Point cen1 = (iab + eab) / 2;
      double rad1 = abs(iab - eab) / 2;
      Circle c1(cen1, rad1);
      Point ica = (c * ra + a * rc) / (rc + ra);
      Point eca = (c * ra - a * rc) / (-rc + ra);
      Point cen2 = (ica + eca) / 2;
      double rad2 = abs(ica - eca) / 2;
      Circle c2(cen2, rad2);
      alt = crosspoint(c1, c2);
    }
    double Min = INF;
    for (int i = 0; i < alt.size(); ++i) {
      double da = abs(alt[i] - a), db = abs(alt[i] - b), dc = abs(alt[i] - c);
      if (Min > da && da > ra && db > rb && dc > rc) {
        Min = abs(alt[i] - a);
        res = alt[i];
      }
    }
    if (Min < INF - EPS)
      cout << fixed << setprecision(5) << res.x << " " << res.y << endl;
  }
  return 0;
}