#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T Abs(T x) {
  return x < 0 ? -x : x;
}
bool Eq(double a, double b, double eps = 1e-9) { return Abs(a - b) < eps; }
struct P {
  typedef const P& CP;
  double x, y;
  P() {}
  P(double x, double y) : x(x), y(y) {}
  void Read() { scanf("%lf%lf", &x, &y); }
  friend P operator+(CP a, CP b) { return P(a.x + b.x, a.y + b.y); }
  friend P operator-(CP a, CP b) { return P(a.x - b.x, a.y - b.y); }
  friend P operator*(CP a, double k) { return P(a.x * k, a.y * k); }
  double Dot(CP b) const { return x * b.x + y * b.y; }
  double Cross(CP b) const { return x * b.y - y * b.x; }
  double Length2() const { return Dot(*this); }
  double Length() const { return sqrt(Length2()); }
  double Dist(CP b) const { return (*this - b).Length(); }
  P Norm() const {
    double L = Length();
    if (Eq(L, 0)) return P(0, 0);
    return (*this) * (1.0 / L);
  }
  friend bool operator==(CP a, CP b) { return Eq(a.x, b.x) && Eq(a.y, b.y); }
};
typedef const P& CP;
struct Circle {
  P c;
  double r;
  Circle() {}
  Circle(CP c, double r) : c(c), r(r) {}
  void Read() {
    c.Read();
    scanf("%lf", &r);
  }
  friend bool operator<(const Circle& a, const Circle& b) {
    return memcmp(&a, &b, sizeof(a)) < 0;
  }
};
struct Line {
  P a, d;
  Line() {}
  Line(CP a, CP d) : a(a), d(d) {
    this->d = d.Norm();
    if (d == P(0, 0)) throw 0;
  }
  Line(double A, double B, double C) {
    if (!Eq(B, 0))
      a = P(0, -C / B);
    else if (!Eq(A, 0))
      a = P(-C / A, 0);
    else
      throw 0;
    d = P(-B, A).Norm();
    if (d == P(0, 0)) throw 0;
  }
};
struct Intersection {
  int type;
  struct {
    Circle c;
    Line l;
  };
  Intersection() : type(0) {}
  Intersection(Circle c) : c(c), type(1) {}
  Intersection(Line l) : l(l), type(2) {}
};
Intersection S(Circle c1, Circle c2) {
  if (Eq(c1.r, c2.r)) {
    P d = c1.c - c2.c;
    return Intersection(Line((c1.c + c2.c) * 0.5, P(-d.y, d.x).Norm()));
  } else {
    if (c1.r < c2.r) swap(c1, c2);
    P t = c2.c;
    c1.c = c1.c - c2.c;
    c2.c = P(0, 0);
    return Intersection(
        Circle(P(c2.r * c2.r * c1.c.x / (c2.r * c2.r - c1.r * c1.r),
                 c2.r * c2.r * c1.c.y / (c2.r * c2.r - c1.r * c1.r)) +
                   t,
               c1.c.Length() * c1.r * c2.r / (c1.r * c1.r - c2.r * c2.r)));
  }
  return Intersection();
}
vector<P> Intersect(Circle a, Line b) {
  P p = b.a + b.d * (a.c - b.a).Dot(b.d);
  double dd = p.Dist(a.c);
  vector<P> res;
  if (Eq(dd, a.r) || dd < a.r) {
    double tt = a.r * a.r - dd * dd;
    if (Eq(tt, 0)) tt = 0;
    if (tt < 0) return res;
    tt = sqrt(tt);
    res.push_back(p + b.d.Norm() * tt);
    res.push_back(p - b.d * tt);
  }
  return res;
}
vector<P> Intersect(Line a, Line b) {
  double d = b.d.Cross(a.d);
  double du = b.d.Cross(b.a - a.a);
  double dv = a.d.Cross(b.a - a.a);
  if (Eq(d, 0)) return vector<P>();
  du /= d;
  dv /= d;
  P r;
  r = (a.a + a.d * du);
  vector<P> res;
  res.push_back(r);
  return res;
}
vector<P> Intersect(Circle a, Circle b) {
  P t = a.c;
  b.c = b.c - a.c;
  a.c = P(0, 0);
  double dd = b.c.Length();
  if (!Eq(dd, a.r + b.r) && dd > a.r + b.r ||
      !Eq(dd, a.r - b.r) && dd < Abs(a.r - b.r)) {
    return vector<P>();
  }
  vector<P> res = Intersect(a, Line(b.c.x, b.c.y,
                                    0.5 * ((b.r * b.r - a.r * a.r) -
                                           (b.c.x * b.c.x + b.c.y * b.c.y))));
  for (int i = 0; i < res.size(); i++) res[i] = res[i] + t;
  return res;
}
vector<P> Intersect(const Intersection& a, const Intersection& b) {
  if (a.type == 1 && b.type == 1) return Intersect(a.c, b.c);
  if (a.type == 1 && b.type == 2) return Intersect(a.c, b.l);
  if (a.type == 2 && b.type == 1) return Intersect(b.c, a.l);
  if (a.type == 2 && b.type == 2) return Intersect(a.l, b.l);
  return vector<P>();
}
void TestInt(Intersection i, Circle c1, Circle c2) {
  if (i.type == 1) {
    for (int j = 0; j < 10000; j++) {
      double angle = rand() * (1.0 / RAND_MAX) * 2 * acos(-1.0);
      P p = P(cos(angle), sin(angle)) * i.c.r + i.c.c;
      double s1 = c1.r / (p - c1.c).Length();
      double s2 = c2.r / (p - c2.c).Length();
      if (!Eq(s1, s2)) {
        cout << s1 << ' ' << s2 << ' ' << Eq(s1, s2) << endl;
      }
    }
  }
  if (i.type == 2) {
    for (int j = 0; j < 10000; j++) {
      double len = rand() * (1.0 / RAND_MAX) * 10;
      P p = i.l.a + i.l.d * len;
      double s1 = c1.r / (p - c1.c).Length();
      double s2 = c2.r / (p - c2.c).Length();
      if (!Eq(s1, s2)) {
        cout << s1 << ' ' << s2 << ' ' << Eq(s1, s2) << endl;
      }
    }
  }
}
void TestInt(P p, Circle c[3]) {
  for (int i = 0; i < 1; i++) {
    double s1 = c[0].r / (p - c[0].c).Length();
    double s2 = c[1].r / (p - c[1].c).Length();
    double s3 = c[2].r / (p - c[2].c).Length();
    if (!Eq(s1, s2) || !Eq(s1, s3)) {
      throw 0;
    }
  }
}
int main() {
  Circle cc[3];
  for (int i = 0; i < 3; i++) cc[i].Read();
  P r(0, 0);
  double d = 1e20;
  Intersection i1 = S(cc[0], cc[1]);
  Intersection i2 = S(cc[1], cc[2]);
  vector<P> pp = Intersect(i1, i2);
  if (pp.size() > 0) {
    for (int i = 0; i < pp.size(); i++) {
      double nd = pp[i].Dist(cc[0].c);
      if (nd < d) {
        d = nd;
        r = pp[i];
      }
    }
  }
  if (d != 1e20) {
    printf("%0.5lf %0.5lf\n", r.x, r.y);
  }
  return 0;
}
