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

Difficulty: VERY_HARD
Tags: Geometry

Starter code:

Solutions:
import math
(x1, y1, r1) = [int(_) for _ in input().split()]
(x2, y2, r2) = [int(_) for _ in input().split()]
(x3, y3, r3) = [int(_) for _ in input().split()]

def get_line(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	if x1 * y2 == x2 * y1:
		c = 0
		a = 1
		if y1 != 0:
			b = -x1 / y1
		elif y2 != 0:
			b = -x2 / y2
		else:
			a = 0
			b = 1
		return (a, b, c)
	else:
		c = 1
		a = (y1 - y2) / (x1 * y2 - x2 * y1)
		b = (x1 - x2) / (x2 * y1 - x1 * y2)
		return (a, b, c)

def comm(x1, y1, r1, x2, y2, r2):
	if r1 == r2:
		(a, b, c) = get_line((x1, y1), (x2, y2))
		return (True, b, -a, a * (y1 + y2) / 2 - b * (x1 + x2) / 2)
	else:
		c = r1 ** 2 / r2 ** 2
		x = (c * x2 - x1) / (c - 1)
		y = (c * y2 - y1) / (c - 1)
		r = math.sqrt((c * (x1 - x2) ** 2 + c * (y1 - y2) ** 2) / (c - 1) ** 2)
		return (False, x, y, r)

def get_angle(x, y, r, x0, y0):
	dist = math.sqrt((x0 - x) ** 2 + (y0 - y) ** 2)
	return math.asin(r / dist)

def get_points(a, b, c, x, y, r):
	dist = abs(a * x + b * y + c) / math.sqrt(a ** 2 + b ** 2)
	if dist <= r:
		aa = a ** 2 + b ** 2
		bb = 2 * a * b * y + 2 * a * c - 2 * b ** 2 * x
		cc = b ** 2 * x ** 2 + (b * y + c) ** 2 - b ** 2 * r ** 2
		delta = math.sqrt(bb ** 2 - 4 * aa * cc)
		if delta == 0:
			xx = -bb / 2 / aa
			if b == 0:
				yy = math.sqrt(r ** 2 - (xx - x) ** 2) + y
			else:
				yy = (-c - a * xx) / b
			return (1, [(xx, yy)])
		else:
			xx1 = (-bb + delta) / 2 / aa
			if b == 0:
				tmp1 = math.sqrt(r ** 2 - (xx1 - x) ** 2) + y
				tmp2 = -math.sqrt(r ** 2 - (xx1 - x) ** 2) + y
				yy1 = 0
				if abs(a * xx1 + b * tmp1 + c) <= 0.001:
					yy1 = tmp1
				if abs(a * xx1 + b * tmp2 + c) <= 0.001:
					yy1 = tmp2
			else:
				yy1 = (-c - a * xx1) / b
			xx2 = (-bb - delta) / 2 / aa
			if b == 0:
				tmp1 = math.sqrt(r ** 2 - (xx2 - x) ** 2) + y
				tmp2 = -math.sqrt(r ** 2 - (xx2 - x) ** 2) + y
				yy2 = 0
				if abs(a * xx2 + b * tmp1 + c) <= 0.001:
					yy2 = tmp1
				if abs(a * xx2 + b * tmp2 + c) <= 0.001:
					yy2 = tmp2
			else:
				yy2 = (-c - a * xx2) / b
			return (2, [(xx1, yy1), (xx2, yy2)])
	return (0, [])
items1 = comm(x1, y1, r1, x2, y2, r2)
items2 = comm(x1, y1, r1, x3, y3, r3)
if not items1[0]:
	(items1, items2) = (items2, items1)
if items1[0] and items2[0]:
	(a1, b1, c1) = items1[1:]
	(a2, b2, c2) = items2[1:]
	if a1 * b2 != a2 * b1:
		print((b1 * c2 - b2 * c1) / (b2 * a1 - a2 * b1), (a1 * c2 - a2 * c1) / (a2 * b1 - a1 * b2))
elif items1[0] and (not items2[0]):
	(a, b, c) = items1[1:]
	(x, y, r) = items2[1:]
	(num, points) = get_points(a, b, c, x, y, r)
	if num == 1:
		print(points[0][0], points[0][1])
	elif num == 2:
		(xx1, yy1) = points[0]
		(xx2, yy2) = points[1]
		angle1 = get_angle(x1, y1, r1, xx1, yy1)
		angle2 = get_angle(x1, y1, r1, xx2, yy2)
		if angle1 >= angle2:
			print(xx1, yy1)
		else:
			print(xx2, yy2)
else:
	(xx1, yy1, rr1) = items1[1:]
	(xx2, yy2, rr2) = items2[1:]
	(a, b, c) = (2 * (xx1 - xx2), 2 * (yy1 - yy2), xx2 ** 2 + yy2 ** 2 - rr2 ** 2 - (xx1 ** 2 + yy1 ** 2 - rr1 ** 2))
	(num, points) = get_points(a, b, c, xx1, yy1, rr1)
	if num == 1:
		print(points[0][0], points[0][1])
	elif num == 2:
		(xxx1, yyy1) = points[0]
		(xxx2, yyy2) = points[1]
		angle1 = get_angle(x1, y1, r1, xxx1, yyy1)
		angle2 = get_angle(x1, y1, r1, xxx2, yyy2)
		if angle1 >= angle2:
			print(xxx1, yyy1)
		else:
			print(xxx2, yyy2)


from math import sqrt

def rt(s1, s2):
	(x1, y1, r1) = s1
	(x2, y2, r2) = s2
	if r1 == r2:
		k = False
		m = x2 - x1
		n = y2 - y1
		e = (m, n, -0.5 * (m * (x1 + x2) + n * (y1 + y2)))
	else:
		k = True
		m = r1 * r1
		n = r2 * r2
		d = m - n
		e = ((m * x2 - n * x1) / d, (m * y2 - n * y1) / d, m * n * ((x1 - x2) ** 2 + (y1 - y2) ** 2) / (d * d))
	return (k, e)

def tr(r, eps=1e-05):
	return -eps < r < eps

def trt(e1, e2, p):
	(a1, b1, c1) = e1
	(a2, b2, c2) = e2
	d = a1 * b2 - b1 * a2
	if not tr(d):
		p.append(((b1 * c2 - c1 * b2) / d, (c1 * a2 - a1 * c2) / d))

def rtr(e1, e2, p):
	(a, b, c) = e1
	(cx, cy, rr) = e2
	ab = a * a + b * b
	xy = a * cx + b * cy + c
	zz = xy / ab
	dd = rr - xy * zz
	px = cx - a * zz
	py = cy - b * zz
	if tr(dd):
		p.append((px, py))
	elif dd > 0.0:
		t = sqrt(dd / ab)
		ta = t * a
		tb = t * b
		p.extend([(px + tb, py - ta), (px - tb, py + ta)])

def rtt(e1, e2, p):
	(x1, y1, r1) = e1
	(x2, y2, r2) = e2
	a = x2 - x1
	b = y2 - y1
	if (r1 + r2) ** 2 < a * a + b * b:
		return
	c = -0.5 * (a * (x1 + x2) + b * (y1 + y2) + r1 - r2)
	rtr((a, b, c), e1, p)

def main():
	(s1, s2, s3) = (tuple(map(float, input().split())) for _ in range(3))
	(c1, eq1) = rt(s1, s2)
	(c2, eq2) = rt(s2, s3)
	point = []
	if c1 and c2:
		rtt(eq1, eq2, point)
	elif c1:
		rtr(eq2, eq1, point)
	elif c2:
		rtr(eq1, eq2, point)
	else:
		trt(eq1, eq2, point)
	if point:
		if len(point) == 1:
			best = point[0]
		else:
			(x, y, _) = s1
			best = min(point, key=lambda q: (q[0] - x) ** 2 + (q[1] - y) ** 2)
		print('{:.5f} {:.5f}'.format(*best))
main()


import sys
import math
import functools
EPS = 0.0001

def points_same_observation_angle(circle1, circle2):
	(x1, y1, r1) = circle1
	(x2, y2, r2) = circle2
	a = r2 * r2 - r1 * r1
	b = 2 * x2 * r1 * r1 - 2 * x1 * r2 * r2
	c = 2 * y2 * r1 * r1 - 2 * y1 * r2 * r2
	d = (x1 * x1 + y1 * y1) * r2 * r2 - (x2 * x2 + y2 * y2) * r1 * r1
	return (a, b, c, d)

def circle_center_radius_from_equation(a, b, c, d):
	ox = b / (-2 * a)
	oy = c / (-2 * a)
	r = math.sqrt(ox * ox + oy * oy - d / a)
	return (ox, oy, r)

def lines_intersection(line1, line2):
	(a1, b1, c1) = line1
	(a2, b2, c2) = line2
	D = a1 * b2 - a2 * b1
	Dx = c1 * b2 - c2 * b1
	Dy = a1 * c2 - a2 * c1
	if math.fabs(D) >= EPS:
		INTXN_x1 = Dx / D
		INTXN_y1 = Dy / D
		return {(INTXN_x1, INTXN_y1)}
	else:
		return None

def line_circle_intersection(line1, circle1):
	(a1, b1, c1) = line1
	(x1, y1, r1) = circle1
	A = 1 + a1 * a1 / (b1 * b1)
	B = -2 * x1 + 2 * a1 / b1 * (-c1 / b1 + y1)
	C = x1 * x1 + (c1 / b1 - y1) ** 2 - r1 * r1
	discriminant = B * B - 4 * A * C
	if math.fabs(discriminant) < EPS:
		INTXN_x1 = -B / (2 * A)
		INTXN_y1 = (c1 - a1 * INTXN_x1) / b1
		return {(INTXN_x1, INTXN_y1)}
	elif discriminant < 0:
		return None
	else:
		discriminant = math.sqrt(discriminant)
		INTXN_x1 = (-B + discriminant) / (2 * A)
		INTXN_y1 = (c1 - a1 * INTXN_x1) / b1
		INTXN_x2 = (-B - discriminant) / (2 * A)
		INTXN_y2 = (c1 - a1 * INTXN_x2) / b1
		return {(INTXN_x1, INTXN_y1), (INTXN_x2, INTXN_y2)}

def circles_intersection(circle1, circle2):
	(x1, y1, r1) = circle1
	(x2, y2, r2) = circle2
	dx = x2 - x1
	dy = y2 - y1
	dist_centers = math.hypot(dx, dy)
	if dist_centers < EPS and math.fabs(r1 - r2) < EPS:
		return None
	elif dist_centers < math.fabs(r1 - r2):
		return None
	elif dist_centers > r1 + r2:
		return None
	else:
		a = (r1 * r1 - r2 * r2 + dist_centers * dist_centers) / (2 * dist_centers)
		h = math.sqrt(r1 * r1 - a * a)
		x3 = x1 + dx * a / dist_centers
		y3 = y1 + dy * a / dist_centers
		offset_x = -dy * (h / dist_centers)
		offset_y = dx * (h / dist_centers)
		INTXN_x1 = x3 + offset_x
		INTXN_y1 = y3 + offset_y
		INTXN_x2 = x3 - offset_x
		INTXN_y2 = y3 - offset_y
		return {(INTXN_x1, INTXN_y1), (INTXN_x2, INTXN_y2)}

def main():
	(circle1, circle2, circle3) = (tuple(map(float, sys.stdin.readline().strip().split())) for _ in range(3))
	(a1, b1, c1, d1) = points_same_observation_angle(circle1, circle2)
	(a2, b2, c2, d2) = points_same_observation_angle(circle1, circle3)
	if math.fabs(a1) < EPS and math.fabs(a2) < EPS:
		INTXN_line1 = (b1, c1, -d1)
		INTXN_line2 = (b2, c2, -d2)
		sol = lines_intersection(INTXN_line1, INTXN_line2)
	elif math.fabs(a1) < EPS or math.fabs(a2) < EPS:
		if math.fabs(a1) < EPS:
			INTXN_line1 = (b1, c1, -d1)
			INTXN_circle1 = circle_center_radius_from_equation(a2, b2, c2, d2)
		else:
			INTXN_line1 = (b2, c2, -d2)
			INTXN_circle1 = circle_center_radius_from_equation(a1, b1, c1, d1)
		sol = line_circle_intersection(INTXN_line1, INTXN_circle1)
	else:
		INTXN_circle1 = circle_center_radius_from_equation(a1, b1, c1, d1)
		INTXN_circle2 = circle_center_radius_from_equation(a2, b2, c2, d2)
		sol = circles_intersection(INTXN_circle1, INTXN_circle2)
	if sol is None:
		sys.stdout.write('\n')
	else:
		f = functools.partial(lambda p1, p2: p2[2] / math.hypot(p1[0] - p2[0], p1[1] - p2[0]), p2=circle1)
		best_sol = max(sol, key=f)
		sys.stdout.write('{0:.5f} {1:.5f}'.format(best_sol[0], best_sol[1]) + '\n')
main()


import math, sys, re, itertools, pprint, collections, copy
(ri, rai) = (lambda : int(input()), lambda : list(map(int, input().split())))
eps = 1e-05

def all_less_eps(*args):
	for x in args:
		if abs(x) > eps:
			return False
	return True

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __add__(self, other):
		return Point(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
		return Point(self.x - other.x, self.y - other.y)

	def len(self):
		return math.sqrt(self.x ** 2 + self.y ** 2)

	def __rmul__(self, scalar):
		return Point(scalar * self.x, scalar * self.y)

	def normalize(self):
		return 1 / self.len() * self

	def __str__(self):
		return '({}, {})'.format(self.x, self.y)

	def __repr__(self):
		return '({}, {})'.format(self.x, self.y)

	def dist_to(self, o):
		if isinstance(o, Point):
			return (o - self).len()
		if isinstance(o, Line):
			l = line_by_point_and_direction(self, o.norm())
			x = o.intersect(l)
			return self.dist_to(x)

	def center(self, o):
		if isinstance(o, Point):
			return Point((self.x + o.x) / 2, (self.y + o.y) / 2)
		if isinstance(o, Line):
			l = line_by_point_and_direction(self, o.norm())
			x = o.intersect(l)
			return self.center(x)

	def midle_perpendicular(self, b):
		c = self.center(b)
		n = Point(self.x - b.x, self.y - b.y)
		return line_by_point_and_normal(c, n)

	def __neg__(self):
		return Point(-self.x, -self.y)

	def __eq__(self, o):
		return all_less_eps(self.x - o.x, self.y - o.y)

class Circle:

	def __init__(self, x, y, r):
		self.x = x
		self.y = y
		self.r = r

	def __str__(self):
		return 'Circle({}, {}, {})'.format(self.x, self.y, self.r)

	def center(self):
		return Point(self.x, self.y)

	def move(self, p):
		return Circle(self.x + p.x, self.y + p.y, self.r)

	def intersect(self, o):
		if isinstance(o, Line):
			return o.intersect(self)
		if isinstance(o, Circle):
			(o1, o2) = (self, o)
			l = Line(2 * (o2.x - o1.x), 2 * (o2.y - o1.y), o1.x ** 2 - o2.x ** 2 + o1.y ** 2 - o2.y ** 2 - o1.r ** 2 + o2.r ** 2)
			return l.intersect(o1)

	def __eq__(self, o):
		return all_less_eps(self.x - o.x, self.y - o.y, self.r - o.r)

	def angle_vision_from(self, p: Point):
		return 2 * math.atan(self.r / p.dist_to(self.center()))

class Line:

	def __init__(self, a, b, c):
		self.a = a
		self.b = b
		self.c = c

	def __str__(self):
		return 'Line({}, {}, {})'.format(self.a, self.b, self.c)

	def dir(self):
		return Point(-self.b, self.a)

	def norm(self):
		return Point(self.a, self.b)

	def move(self, p):
		return Line(self.a, self.b, self.a * p.x + self.b * p.y + self.c)

	def intersect(self, o):
		if isinstance(o, Line):
			x = solve_lineq2([[self.a, self.b], [o.a, o.b]], [-self.c, -o.c])
			if x is None:
				return []
			return [Point(x[0], x[1])]
		if isinstance(o, Circle):
			l = self
			if abs(l.a) < eps:
				y = -l.c / l.b
				xx = solve_sqeq(1, -2 * o.x, o.x ** 2 + (y - o.y) ** 2 - o.r ** 2)
				return [Point(x, y) for x in xx]
			a = l.a ** 2 + l.b ** 2
			b = 2 * (l.b * l.c + l.a * l.b * o.x - l.a ** 2 * o.y)
			c = l.c ** 2 + 2 * l.a * l.c * o.x + l.a ** 2 * o.x ** 2 + l.a ** 2 * o.y ** 2 - o.r ** 2 * l.a ** 2
			yy = solve_sqeq(a, b, c)
			return [Point((-l.b * y - l.c) / l.a, y) for y in yy]

	def __eq__(self, o):
		return all_less_eps(self.a - o.a, self.b - o.b, self.c - o.c)

def line_by_2_points(a, b):
	return line_by_point_and_direction(a, b - a)

def line_by_point_and_direction(M, p):
	return Line(p.y, -p.x, p.x * M.y - p.y * M.x)

def line_by_point_and_normal(p, n):
	return line_by_point_and_direction(p, Point(-n.y, n.x))

def det2(a):
	return a[0][0] * a[1][1] - a[0][1] * a[1][0]

def solve_sqeq(a, b, c):
	if abs(a) < eps:
		return [-c / b]
	D = b ** 2 - 4 * a * c
	if abs(D) < eps:
		return [-b / (2 * a)]
	if D < 0:
		return []
	x1 = (-b + math.sqrt(D)) / (2 * a)
	x2 = (-b - math.sqrt(D)) / (2 * a)
	return [x1, x2]

def solve_lineq2(a: list, b: list):
	detA = det2(a)
	if abs(detA) < eps:
		return None
	x = [None] * 2
	t = copy.deepcopy(a)
	(t[0][0], t[1][0]) = (b[0], b[1])
	x[0] = det2(t) / detA
	t = copy.deepcopy(a)
	(t[0][1], t[1][1]) = (b[0], b[1])
	x[1] = det2(t) / detA
	return x

def solve_for_2_circle(c1: Circle, c2: Circle):
	A = c1.center()
	B = c2.center()
	if c1.r == c2.r:
		return A.midle_perpendicular(B)
	else:
		e = (B - A).normalize()
		a = c1.r / c2.r
		l = A.dist_to(B)
		x1 = a * l / (1 + a)
		x2 = a * l / (a - 1)
		H1 = A + x1 * e
		H2 = A + x2 * e
		H = H1.center(H2)
		return Circle(H.x, H.y, H.dist_to(H1))
(c1, c2, c3) = (Circle(*rai()), Circle(*rai()), Circle(*rai()))
o1 = solve_for_2_circle(c1, c2)
o2 = solve_for_2_circle(c1, c3)
ans = o1.intersect(o2)
if len(ans) == 2:
	(a, b) = ans
	(a1, a2) = (c1.angle_vision_from(a), c1.angle_vision_from(b))
	if a1 > a2:
		print(a.x, a.y)
	else:
		print(b.x, b.y)
elif len(ans) == 1:
	a = ans[0]
	print(a.x, a.y)


def hill_climbing(circles):

	def diff(x):
		d = []
		for (y, ry) in circles:
			d.append(abs(x - y) / ry)
		ans = 0
		for i in range(3):
			ans += (d[i] - d[(i + 1) % 3]) ** 2
		return ans
	x = 0
	s = 1
	for (y, _) in circles:
		x += y / 3
	while s > 1e-06:
		d0 = diff(x)
		if d0 > diff(x + s):
			x += s
		elif d0 > diff(x - s):
			x -= s
		elif d0 > diff(x + s * 1j):
			x += s * 1j
		elif d0 > diff(x - s * 1j):
			x -= s * 1j
		else:
			s *= 0.7
	return x if diff(x) < 1e-05 else None
if __name__ == '__main__' and '__file__' in globals():
	circles = []
	for _ in range(3):
		(x, y, r) = map(int, input().split())
		circles.append((x + y * 1j, r))
	ans = hill_climbing(circles)
	if ans is not None:
		print('{:.5f} {:.5f}'.format(ans.real, ans.imag))


__author__ = 'Darren'

def solve():
	import sys
	stdin = sys.stdin if True else open('data')
	vertices = [[float(x) for x in line] for line in map(str.split, stdin)]
	p = [sum((v[0] for v in vertices)) / 3, sum((v[1] for v in vertices)) / 3]
	step = 1
	while step > 1e-06:
		error = calc_error(p, vertices)
		if error < 1e-08:
			print('%.5f %.5f' % (p[0], p[1]))
			break
		if error > calc_error((p[0] + step, p[1]), vertices):
			p[0] += step
			continue
		if error > calc_error((p[0] - step, p[1]), vertices):
			p[0] -= step
			continue
		if error > calc_error((p[0], p[1] + step), vertices):
			p[1] += step
			continue
		if error > calc_error((p[0], p[1] - step), vertices):
			p[1] -= step
			continue
		step *= 0.5

def calc_error(p, vertices):
	ratios = [((p[0] - v[0]) ** 2 + (p[1] - v[1]) ** 2) ** 0.5 / v[2] for v in vertices]
	average = sum(ratios) / 3
	return (ratios[0] - average) ** 2 + (ratios[1] - average) ** 2 + (ratios[2] - average) ** 2
solve()


__author__ = 'Eddie'
import sys

def get_filehandler(is_file):
	if is_file:
		return open(file='data')
	else:
		import sys
		return sys.stdin

def get_weighted_distance(vertices, pfree):
	return [((p[0] - pfree[0]) ** 2 + (p[1] - pfree[1]) ** 2) ** 0.5 / p[2] for p in vertices]

def get_error(distance):
	(p1, p2, p3) = distance
	avg_p = (p1 + p2 + p3) / 3
	return (avg_p - p1) ** 2 + (avg_p - p2) ** 2 + (avg_p - p3) ** 2
fh = get_filehandler(is_file=False)
vertices = [[float(x) for x in line] for line in map(str.split, fh.readlines())]
pfree = [sum([v[0] for v in vertices]) / 3, sum((v[1] for v in vertices)) / 3]
error = get_error(get_weighted_distance(vertices, pfree))
d = 2
while True:
	error = get_error(get_weighted_distance(vertices, pfree))
	if error < 1e-08:
		print('{:.5f} {:.5f}'.format(pfree[0], pfree[1]))
		break
	if get_error(get_weighted_distance(vertices, (pfree[0] + d, pfree[1]))) < error:
		pfree[0] += d
		continue
	if get_error(get_weighted_distance(vertices, (pfree[0] - d, pfree[1]))) < error:
		pfree[0] -= d
		continue
	if get_error(get_weighted_distance(vertices, (pfree[0], pfree[1] + d))) < error:
		pfree[1] += d
		continue
	if get_error(get_weighted_distance(vertices, (pfree[0], pfree[1] - d))) < error:
		pfree[1] -= d
		continue
	d *= 0.5
	if d < 1e-05:
		break


import math

def line_through_two_points(x1, y1, x2, y2):
	a = y1 - y2
	b = x2 - x1
	c = x1 * y2 - x2 * y1
	return [a, b, c]

def circle_and_line_intersection0(r_r, a, b, c):
	a2 = a * a
	b2 = b * b
	a2b2 = a2 + b2
	x0 = -a * c / a2b2
	y0 = -b * c / a2b2
	d2 = r_r - c * c / a2b2
	if d2 < 0:
		return []
	if not d2:
		return [[x0, y0]]
	mult = math.sqrt(d2 / a2b2)
	a_mult = a * mult
	b_mult = b * mult
	x1 = x0 + b_mult
	y1 = y0 - a_mult
	x2 = x0 - b_mult
	y2 = y0 + a_mult
	return [[x1, y1], [x2, y2]]

def circle_and_line_intersection(xc, yc, r_r, a, b, c):
	points = circle_and_line_intersection0(r_r, a, b, c + a * xc + b * yc)
	for point in points:
		point[0] += xc
		point[1] += yc
	return points

def circle_and_circle_intersection0(x2, y2, r1_r1, r2_r2):
	return circle_and_line_intersection0(r1_r1, -2 * x2, -2 * y2, x2 * x2 + y2 * y2 + r1_r1 - r2_r2)

def circle_and_circle_intersection(x1, y1, x2, y2, r1_r1, r2_r2):
	points = circle_and_circle_intersection0(x2 - x1, y2 - y1, r1_r1, r2_r2)
	for point in points:
		point[0] += x1
		point[1] += y1
	return points

def is_point_in_triangle(ax, ay, bx, by, cx, cy, x, y):
	ax -= x
	ay -= y
	bx -= x
	by -= y
	cx -= x
	cy -= y
	ab = ax * by - ay * bx
	if not ab:
		return False
	bc = bx * cy - by * cx
	if not bc:
		return False
	if ab > 0.0 and bc < 0.0:
		return False
	if ab < 0.0 and bc > 0.0:
		return False
	ca = cx * ay - cy * ax
	if not ca:
		return False
	if ab > 0.0 and ca < 0.0:
		return False
	if ab < 0.0 and ca > 0.0:
		return False
	return True

def get_dist2(x1, y1, x2, y2):
	return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)

def get_circ(x1, y1, RR1, x2, y2, RR2):
	xc = (RR2 * x1 - RR1 * x2) / (RR2 - RR1)
	yc = (RR2 * y1 - RR1 * y2) / (RR2 - RR1)
	RR = RR1 * RR2 / ((RR2 - RR1) * (RR2 - RR1))
	RR *= get_dist2(x1, y1, x2, y2)
	return [xc, yc, RR]
(Ax, Ay, Ra) = map(float, input().split())
(Bx, By, Rb) = map(float, input().split())
(Cx, Cy, Rc) = map(float, input().split())
if Ra == Rb and Rb == Rc:
	ax_bx = Ax - Bx
	ay_by = Ay - By
	bx_cx = Bx - Cx
	by_cy = By - Cy
	cx_ax = Cx - Ax
	cy_ay = Cy - Ay
	a2 = bx_cx * bx_cx + by_cy * by_cy
	b2 = cx_ax * cx_ax + cy_ay * cy_ay
	c2 = ax_bx * ax_bx + ay_by * ay_by
	S = abs(ax_bx * by_cy - ay_by * bx_cx) / 2
	coef = -1 / (8 * S * S)
	alpha_a = coef * a2 * (ax_bx * cx_ax + ay_by * cy_ay)
	alpha_b = coef * b2 * (ax_bx * bx_cx + ay_by * by_cy)
	alpha_c = coef * c2 * (cx_ax * bx_cx + cy_ay * by_cy)
	Ux = alpha_a * Ax + alpha_b * Bx + alpha_c * Cx
	Uy = alpha_a * Ay + alpha_b * By + alpha_c * Cy
	print('%.5f %.5f' % (Ux, Uy))
	exit()
RRa = Ra * Ra
RRb = Rb * Rb
RRc = Rc * Rc
circs = []
if Ra != Rb:
	circs.append(get_circ(Ax, Ay, RRa, Bx, By, RRb))
if Rb != Rc:
	circs.append(get_circ(Bx, By, RRb, Cx, Cy, RRc))
if Rc != Ra and len(circs) < 2:
	circs.append(get_circ(Cx, Cy, RRc, Ax, Ay, RRa))
points = circle_and_circle_intersection(circs[0][0], circs[0][1], circs[1][0], circs[1][1], circs[0][2], circs[1][2])
if not points:
	exit()
if len(points) < 2:
	(Ux, Uy) = points[0]
else:
	dd0 = get_dist2(points[0][0], points[0][1], Ax, Ay)
	dd1 = get_dist2(points[1][0], points[1][1], Ax, Ay)
	(Ux, Uy) = points[0] if dd0 < dd1 else points[1]
print('%.5f %.5f' % (Ux, Uy))


from math import *
(x1, y1, r1) = map(float, input().split())
(x2, y2, r2) = map(float, input().split())
(x3, y3, r3) = map(float, input().split())
(x, y) = ((x1 + x2 + x3) / 3, (y1 + y2 + y3) / 3)

def cost(a, b):
	(d1, d2, d3) = (sqrt((x1 - a) ** 2 + (y1 - b) ** 2), sqrt((x2 - a) ** 2 + (y2 - b) ** 2), sqrt((x3 - a) ** 2 + (y3 - b) ** 2))
	(angle1, angle2, angle3) = (d1 / r1, d2 / r2, d3 / r3)
	return (angle1 - angle2) ** 2 + (angle2 - angle3) ** 2 + (angle3 - angle1) ** 2
t = 1.0
while t > 1e-05:
	if cost(x + t, y) < cost(x, y):
		x += t
	elif cost(x - t, y) < cost(x, y):
		x -= t
	elif cost(x, y + t) < cost(x, y):
		y += t
	elif cost(x, y - t) < cost(x, y):
		y -= t
	else:
		t /= 2
if fabs(cost(x, y)) < 1e-05:
	print('{:5f} {:5f}'.format(x, y))


import math
pt = dict()

def dis(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)

def cost(p, x, y):
	ang = list()
	for i in range(3):
		ang.append(dis(p[i], [x, y]) / p[i][2])
	diff = list()
	for i in range(3):
		diff.append(ang[i] - ang[(i + 1) % 3])
	ret = 0
	for i in range(3):
		ret += diff[i] * diff[i]
	return ret
dx = [0, 1, -1, 0]
dy = [1, 0, 0, -1]
err = 1e-06
p = list()
for i in range(3):
	p.append(list((float(x) for x in input().split(' '))))
ans = list()
ans.append((p[0][0] + p[1][0] + p[2][0]) / 3.0)
ans.append((p[0][1] + p[1][1] + p[2][1]) / 3.0)
ncost = cost(p, ans[0], ans[1])
tmp = [0, 0]
step = 1.0
flag = False
i = 0
while i < 300000 and ncost > err:
	flag = False
	for k in range(4):
		tmp[0] = ans[0] + step * dx[k]
		tmp[1] = ans[1] + step * dy[k]
		if ncost > cost(p, tmp[0], tmp[1]):
			ncost = cost(p, tmp[0], tmp[1])
			ans = list(tmp)
			flag = True
	i += 1
	if not flag:
		step *= 0.5
if cost(p, ans[0], ans[1]) <= err:
	print('{0} {1}'.format(round(ans[0], 5), round(ans[1], 5)))


def twoCirclesCreateOneCircle(x1, y1, r1, x2, y2, r2):
	return (r2 * r2 - r1 * r1, 2 * x2 * r1 * r1 - 2 * x1 * r2 * r2, 2 * y2 * r1 * r1 - 2 * y1 * r2 * r2, r2 * r2 * (x1 * x1 + y1 * y1) - r1 * r1 * (x2 * x2 + y2 * y2))

def circleCenterRound(a, b, c, d):
	return (-b / (2 * a), -c / (2 * a), ((b * b + c * c - 4 * a * d) / (4 * a * a)) ** 0.5)

def jointOfTwoLines(a1, b1, c1, a2, b2, c2):
	return ((c2 * b1 - c1 * b2) / (a1 * b2 - a2 * b1), (c2 * a1 - c1 * a2) / (b1 * a2 - b2 * a1))

def jointOfLineAndCircle(a1, b1, c1, x1, y1, r):
	if (a1 * x1 + b1 * y1 + c1) ** 2 / (a1 ** 2 + b1 ** 2) > r ** 2:
		return (False, False, False, False)
	elif b1 != 0:
		a = 1 + a1 * a1 / (b1 * b1)
		b = -2 * x1 + 2 * a1 / b1 * (c1 / b1 + y1)
		c = x1 * x1 + (c1 / b1 + y1) ** 2 - r * r
		x2 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
		x3 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
		y2 = -a1 * x2 / b1 - c1 / b1
		y3 = -a1 * x3 / b1 - c1 / b1
		return (x2, y2, x3, y3)
	else:
		x2 = -c1 / a1
		x3 = -c1 / a1
		y2 = y1 + (r ** 2 - (x2 - x1) ** 2) ** 0.5
		y3 = y1 - (r ** 2 - (x3 - x1) ** 2) ** 0.5
		return (x2, y2, x3, y3)

def jointOfCircles(x1, y1, r1, x2, y2, r2):
	(a, b, c, d) = jointOfLineAndCircle(2 * x2 - 2 * x1, 2 * y2 - 2 * y1, x1 * x1 + y1 * y1 - x2 * x2 - y2 * y2 + r2 ** 2 - r1 ** 2, x1, y1, r1)
	return (a, b, c, d)

def main():
	[x1, y1, r1] = [eval(x) for x in str.split(input())]
	[x2, y2, r2] = [eval(x) for x in str.split(input())]
	[x3, y3, r3] = [eval(x) for x in str.split(input())]
	(a1, b1, c1, d1) = twoCirclesCreateOneCircle(x1, y1, r1, x2, y2, r2)
	(a2, b2, c2, d2) = twoCirclesCreateOneCircle(x2, y2, r2, x3, y3, r3)
	if abs(a1) < 0.0001 and abs(a2) < 0.0001:
		(x4, y4) = jointOfTwoLines(b1, c1, d1, b2, c2, d2)
		print(x4, y4)
	if abs(a1) < 0.0001 and abs(a2) >= 0.0001:
		(x4, y4, r4) = circleCenterRound(a2, b2, c2, d2)
		(x5, y5, x6, y6) = jointOfLineAndCircle(b1, c1, d1, x4, y4, r4)
		if x5 == False:
			print()
		elif (x5 - x1) ** 2 + (y5 - y1) ** 2 < (x6 - x1) ** 2 + (y6 - y1) ** 2:
			print(x5, y5)
		else:
			print(x6, y6)
	if abs(a2) < 0.0001 and abs(a1) >= 0.0001:
		(x4, y4, r4) = circleCenterRound(a1, b1, c1, d1)
		(x5, y5, x6, y6) = jointOfLineAndCircle(b2, c2, d2, x4, y4, r4)
		if x5 == False:
			print()
		elif (x5 - x1) ** 2 + (y5 - y1) ** 2 < (x6 - x1) ** 2 + (y6 - y1) ** 2:
			print(x5, y5)
		else:
			print(x6, y6)
	if abs(a2) > 0.0001 and abs(a1) > 0.0001:
		(x4, y4, r4) = circleCenterRound(a1, b1, c1, d1)
		(x5, y5, r5) = circleCenterRound(a2, b2, c2, d2)
		(x6, y6, x7, y7) = jointOfCircles(x4, y4, r4, x5, y5, r5)
		if x6 == False:
			print()
		elif (x6 - x1) ** 2 + (y6 - y1) ** 2 < (x7 - x1) ** 2 + (y7 - y1) ** 2:
			print(x6, y6)
		else:
			print(x7, y7)
main()


from math import sqrt, inf
eps = 1e-08

def find_ll(A1, B1, C1, A2, B2, C2):
	if abs(A2 * B1 - A1 * B2) > eps:
		return ((B2 * C1 - B1 * C2) / (A2 * B1 - A1 * B2), -(A2 * C1 - A1 * C2) / (A2 * B1 - A1 * B2))
	else:
		return (inf, inf)

def find_lc(A, B, C, X, Y, R2):
	pp = find_ll(A, B, C, -B, A, B * X - A * Y)
	h = sqrt((pp[0] - X) ** 2 + (pp[1] - Y) ** 2)
	if sqrt(R2) >= h:
		d = sqrt(R2 - h * h)
		x1 = pp[0] - d / sqrt(A ** 2 + B ** 2) * -B
		y1 = pp[1] - d / sqrt(A ** 2 + B ** 2) * +A
		x2 = pp[0] + d / sqrt(A ** 2 + B ** 2) * -B
		y2 = pp[1] + d / sqrt(A ** 2 + B ** 2) * +A
		return ((x1, y1), (x2, y2))
	else:
		return ((inf, inf), (inf, inf))

def find_cc(X1, Y1, R12, X2, Y2, R22):
	d = sqrt((X1 - X2) ** 2 + (Y1 - Y2) ** 2)
	a = (R12 - R22 + d ** 2) / (2 * d)
	X3 = X1 + a / d * (X2 - X1)
	Y3 = Y1 + a / d * (Y2 - Y1)
	if sqrt(R12) >= a:
		h = sqrt(R12 - a ** 2)
		X4 = X3 + h / d * (Y2 - Y1)
		Y4 = Y3 - h / d * (X2 - X1)
		X5 = X3 - h / d * (Y2 - Y1)
		Y5 = Y3 + h / d * (X2 - X1)
		return ((X4, Y4), (X5, Y5))
	else:
		return ((inf, inf), (inf, inf))
(x1, y1, r1) = map(float, input().split(' '))
(x2, y2, r2) = map(float, input().split(' '))
(x3, y3, r3) = map(float, input().split(' '))
A1 = (r2 / r1) ** 2 - 1
B1x = -2 * x1 * (r2 / r1) ** 2 + 2 * x2
B1y = -2 * y1 * (r2 / r1) ** 2 + 2 * y2
C1 = (r2 / r1) ** 2 * (x1 ** 2 + y1 ** 2) - (x2 ** 2 + y2 ** 2)
if abs(A1) > eps:
	O1x = -B1x / (2 * A1)
	O1y = -B1y / (2 * A1)
	R12 = -(C1 / A1 - O1x ** 2 - O1y ** 2)
A2 = (r3 / r1) ** 2 - 1
B2x = -2 * x1 * (r3 / r1) ** 2 + 2 * x3
B2y = -2 * y1 * (r3 / r1) ** 2 + 2 * y3
C2 = (r3 / r1) ** 2 * (x1 ** 2 + y1 ** 2) - (x3 ** 2 + y3 ** 2)
if abs(A2) > eps:
	O2x = -B2x / (2 * A2)
	O2y = -B2y / (2 * A2)
	R22 = -(C2 / A2 - O2x ** 2 - O2y ** 2)
if abs(A1) < eps and abs(A2) < eps:
	sol = find_ll(B1x, B1y, C1, B2x, B2y, C2)
	if sol[0] != inf:
		print('%.5f %.5f' % (sol[0], sol[1]))
elif abs(A1) >= eps and abs(A2) < eps:
	(sol1, sol2) = find_lc(B2x, B2y, C2, O1x, O1y, R12)
	if sol1[0] != inf:
		dist1 = (sol1[0] - x1) ** 2 + (sol1[1] - y1) ** 2
		dist2 = (sol2[0] - x1) ** 2 + (sol2[1] - y1) ** 2
		if dist1 < dist2:
			print('%.5f %.5f' % (sol1[0], sol1[1]))
		else:
			print('%.5f %.5f' % (sol2[0], sol2[1]))
elif abs(A1) < eps and abs(A2) >= eps:
	(sol1, sol2) = find_lc(B1x, B1y, C1, O2x, O2y, R22)
	if sol1[0] != inf:
		dist1 = (sol1[0] - x1) ** 2 + (sol1[1] - y1) ** 2
		dist2 = (sol2[0] - x1) ** 2 + (sol2[1] - y1) ** 2
		if dist1 < dist2:
			print('%.5f %.5f' % (sol1[0], sol1[1]))
		else:
			print('%.5f %.5f' % (sol2[0], sol2[1]))
elif abs(A1) >= eps and abs(A2) >= eps:
	(sol1, sol2) = find_cc(O1x, O1y, R12, O2x, O2y, R22)
	if sol1[0] != inf:
		dist1 = (sol1[0] - x1) ** 2 + (sol1[1] - y1) ** 2
		dist2 = (sol2[0] - x1) ** 2 + (sol2[1] - y1) ** 2
		if dist1 < dist2:
			print('%.5f %.5f' % (sol1[0], sol1[1]))
		else:
			print('%.5f %.5f' % (sol2[0], sol2[1]))


import sys, math

def apollonian_circle(p1, p2, r):
	dx = p2[0] - p1[0]
	x = p1[0] + (r / (1 + r) + r / (r - 1)) / 2 * dx
	dy = p2[1] - p1[1]
	y = p1[1] + (r / (1 + r) + r / (r - 1)) / 2 * dy
	x_ = p1[0] + r / (1 + r) * dx
	y_ = p1[1] + r / (1 + r) * dy
	return ((x, y), math.sqrt(math.pow(x - x_, 2) + math.pow(y - y_, 2)))

def circle_intersections(p1, r1, p2, r2):
	dx = p2[0] - p1[0]
	dy = p2[1] - p1[1]
	theta = math.atan2(dy, dx)
	r = r2 / r1
	x = dx / r1 * math.cos(theta) + dy / r1 * math.sin(theta)
	if 1 + x < r or 1 + r < x or x + r < 1:
		return ()
	alpha = math.acos((math.pow(x, 2) + 1 - math.pow(r, 2)) / (2 * x))
	xsol = math.cos(alpha)
	ysol = math.sin(alpha)
	q1x = p1[0] + (xsol * math.cos(theta) - ysol * math.sin(theta)) * r1
	q1y = p1[1] + (xsol * math.sin(theta) + ysol * math.cos(theta)) * r1
	q2x = p1[0] + (xsol * math.cos(theta) + ysol * math.sin(theta)) * r1
	q2y = p1[1] + (xsol * math.sin(theta) - ysol * math.cos(theta)) * r1
	return ((q1x, q1y), (q2x, q2y))

def dist(x1, y1, x2, y2):
	return math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))

def on_circle(center, radius, pt, tolerance=math.pow(10, -6)):
	return abs(dist(center[0], center[1], pt[0], pt[1]) - radius) < tolerance
c1 = tuple(map(int, sys.stdin.readline().split()))
c2 = tuple(map(int, sys.stdin.readline().split()))
c3 = tuple(map(int, sys.stdin.readline().split()))
p1 = c1[0:2]
p2 = c2[0:2]
p3 = c3[0:2]
r1 = c1[2]
r2 = c2[2]
r3 = c3[2]
numvalues = len(set([r1, r2, r3]))
if numvalues == 3:
	ap1 = apollonian_circle(p1, p2, r1 / r2)
	ap2 = apollonian_circle(p2, p3, r2 / r3)
	ap3 = apollonian_circle(p3, p1, r3 / r1)
	pts_two = circle_intersections(ap1[0], ap1[1], ap2[0], ap2[1])
	pts = []
	for p in pts_two:
		if on_circle(ap3[0], ap3[1], p):
			pts.append(p)
	if pts:
		p = min(pts, key=lambda pt: dist(pt[0], pt[1], p1[0], p1[1]))
		print('%.5f' % p[0] + ' ' + '%.5f' % p[1])
elif numvalues == 2:
	tolerance = math.pow(10, -6)
	if r1 == r2:
		ap2 = apollonian_circle(p2, p3, r2 / r3)
		ap3 = apollonian_circle(p3, p1, r3 / r1)
		pts_two = circle_intersections(ap2[0], ap2[1], ap3[0], ap3[1])
		pts = []
		for p in pts_two:
			diff = abs(dist(p[0], p[1], p1[0], p1[1]) - dist(p[0], p[1], p2[0], p2[1]))
			if diff < tolerance:
				pts.append(p)
		if pts:
			p = min(pts, key=lambda pt: dist(pt[0], pt[1], p1[0], p1[1]))
			print('%.5f' % p[0] + ' ' + '%.5f' % p[1])
	elif r1 == r3:
		ap2 = apollonian_circle(p2, p3, r2 / r3)
		ap1 = apollonian_circle(p1, p2, r1 / r2)
		pts_two = circle_intersections(ap2[0], ap2[1], ap1[0], ap1[1])
		pts = []
		for p in pts_two:
			diff = abs(dist(p[0], p[1], p1[0], p1[1]) - dist(p[0], p[1], p3[0], p3[1]))
			if diff < tolerance:
				pts.append(p)
		if pts:
			p = min(pts, key=lambda pt: dist(pt[0], pt[1], p1[0], p1[1]))
			print('%.5f' % p[0] + ' ' + '%.5f' % p[1])
	elif r2 == r3:
		ap3 = apollonian_circle(p3, p1, r3 / r1)
		ap1 = apollonian_circle(p1, p2, r1 / r2)
		pts_two = circle_intersections(ap3[0], ap3[1], ap1[0], ap1[1])
		pts = []
		for p in pts_two:
			diff = abs(dist(p[0], p[1], p2[0], p2[1]) - dist(p[0], p[1], p3[0], p3[1]))
			if diff < tolerance:
				pts.append(p)
		if pts:
			p = min(pts, key=lambda pt: dist(pt[0], pt[1], p1[0], p1[1]))
			print('%.5f' % p[0] + ' ' + '%.5f' % p[1])
elif numvalues == 1:
	b1 = 0 if p1[1] == p2[1] else 1
	a1 = 1 if b1 == 0 else (p2[0] - p1[0]) / (p2[1] - p1[1])
	c1 = a1 * ((p1[0] + p2[0]) / 2) + b1 * ((p1[1] + p2[1]) / 2)
	b2 = 0 if p1[1] == p3[1] else 1
	a2 = 1 if b2 == 0 else (p3[0] - p1[0]) / (p3[1] - p1[1])
	c2 = a2 * ((p1[0] + p3[0]) / 2) + b2 * ((p1[1] + p3[1]) / 2)
	x = (c1 * b2 - b1 * c2) / (a1 * b2 - b1 * a2)
	y = (a1 * c2 - c1 * a2) / (a1 * b2 - b1 * a2)
	print('%.5f' % x + ' ' + '%.5f' % y)


from math import sqrt
x = [0] * 3
y = [0] * 3
r = [0] * 3
for i in range(3):
	(x[i], y[i], r[i]) = map(int, input().split())
traj = []
for i in range(2):
	sc = r[i + 1] ** 2 - r[i] ** 2
	xc = r[i + 1] ** 2 * x[i] - r[i] ** 2 * x[i + 1]
	yc = r[i + 1] ** 2 * y[i] - r[i] ** 2 * y[i + 1]
	fc = (x[i + 1] * r[i]) ** 2 + (y[i + 1] * r[i]) ** 2 - (x[i] * r[i + 1]) ** 2 - (y[i] * r[i + 1]) ** 2
	if sc != 0:
		xc /= sc
		yc /= sc
		fc /= sc
		fc += xc ** 2 + yc ** 2
		if fc < 0:
			exit()
	else:
		xc *= -2
		yc *= -2
	traj.append([sc == 0, xc, yc, fc])
if not traj[0][0] and (not traj[1][0]):
	(x0, y0, r0) = traj[0][1:]
	(x1, y1, r1) = traj[1][1:]
	traj[0] = [True, 2 * (x1 - x0), 2 * (y1 - y0), r0 - r1 - x0 ** 2 - y0 ** 2 + x1 ** 2 + y1 ** 2]
if not traj[0][0]:
	(traj[0], traj[1]) = (traj[1], traj[0])
if traj[0][0] and traj[1][0]:
	(a0, b0, c0) = traj[0][1:]
	(a1, b1, c1) = traj[1][1:]
	det = a0 * b1 - a1 * b0
	if det != 0:
		print('%.6f %.6f' % ((c0 * b1 - c1 * b0) / det, (a0 * c1 - a1 * c0) / det))
	exit()
(a0, b0, c0) = traj[0][1:]
(x1, y1, r1) = traj[1][1:]
if (a0 * x1 + b0 * y1 - c0) ** 2 > r1 * (a0 ** 2 + b0 ** 2):
	exit()
sdist = (a0 * x1 + b0 * y1 - c0) / (a0 ** 2 + b0 ** 2)
(px, py) = (x1 - a0 * sdist, y1 - b0 * sdist)
clen = sqrt(r1 - sdist * (a0 * x1 + b0 * y1 - c0))
nlen = sqrt(a0 ** 2 + b0 ** 2)
points = []
for mul in (-1, 1):
	points.append((px + mul * b0 * clen / nlen, py - mul * a0 * clen / nlen))
if (points[0][0] - x[0]) ** 2 + (points[0][1] - y[0]) ** 2 > (points[1][0] - x[0]) ** 2 + (points[1][1] - y[0]) ** 2:
	(points[0], points[1]) = (points[1], points[0])
print('%.6f %.6f' % points[0])


import math
import random
p1 = list(map(float, input().split()))
p2 = list(map(float, input().split()))
p3 = list(map(float, input().split()))

def dist(x1, y1, x2, y2):
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def check(x, y):
	ratio1 = dist(p1[0], p1[1], x, y) / p1[2]
	ratio2 = dist(p2[0], p2[1], x, y) / p2[2]
	ratio3 = dist(p3[0], p3[1], x, y) / p3[2]
	diff = (ratio2 - ratio1) ** 2 + (ratio3 - ratio2) ** 2 + (ratio1 - ratio3) ** 2
	return diff
x = (p1[0] + p2[0] + p3[0]) / 3.0
y = (p1[1] + p2[1] + p3[1]) / 3.0
thres = 1e-06
d = 1
prob = 0.1
flag = False
while d > 1e-06:
	cur = check(x, y)
	if cur < thres:
		flag = True
		break
	if check(x - d, y) < cur:
		x = x - d
	elif check(x + d, y) < cur:
		x = x + d
	elif check(x, y - d) < cur:
		y = y - d
	elif check(x, y + d) < cur:
		y = y + d
	else:
		d = d * 0.9
if flag:
	print(x, y)


import math
import itertools

class Circle(object):

	def __init__(self, Cx, Cy, r):
		self._Cx = Cx
		self._Cy = Cy
		self._r = r

def apollonius(Ax, Ay, Bx, By, k):
	Cx = (1 * Ax + k * Bx) / (k + 1)
	Cy = (1 * Ay + k * By) / (k + 1)
	Dx = (Ax - k * Bx) / (1 - k)
	Dy = (Ay - k * By) / (1 - k)
	apollonius_circle = Circle((Cx + Dx) / 2, (Cy + Dy) / 2, ((Dx - Cx) ** 2 + (Dy - Cy) ** 2) ** 0.5 / 2)
	return apollonius_circle

def bisector(Ax, Ay, Bx, By):
	if By - Ay == 0:
		return [(Ax + Bx) / 2]
	(x0, y0, k) = ((Ax + Bx) / 2, (Ay + By) / 2, -(Bx - Ax) / (By - Ay))
	return (x0, y0, k)

def circle_intersection(circle1, circle2):
	x1 = circle1._Cx
	x2 = circle2._Cx
	y1 = circle1._Cy
	y2 = circle2._Cy
	r1 = circle1._r
	r2 = circle2._r
	d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
	if r1 + r2 < d - 10 ** (-4) or abs(r1 - r2) > d + 10 ** (-4):
		return None
	if abs(r1 + r2 - d) <= 10 ** (-4):
		return ((r1 * x2 + r2 * x1) / (r1 + r2), (r1 * y2 + r2 * y1) / (r1 + r2))
	if abs(abs(r1 - r2) - d) <= 10 ** (-4):
		return ((r2 * x1 - r1 * x2) / (r2 - r1), (r2 * y1 - r1 * y2) / (r2 - r1))
	angle = math.acos((r1 ** 2 + r2 ** 2 - d ** 2) / (2 * r1 * r2))
	h = r1 * r2 * math.sin(angle) / d
	AE = (r1 ** 2 - r2 ** 2 + d ** 2) / (2 * d)
	x0 = x1 + AE * (x2 - x1) / d
	y0 = y1 + AE * (y2 - y1) / d
	I1 = (x0 - h * (y2 - y1) / d, y0 + h * (x2 - x1) / d)
	I2 = (x0 + h * (y2 - y1) / d, y0 - h * (x2 - x1) / d)
	return (I1, I2)

def bisector_intersection(bisector1, bisector2):
	if len(bisector1) == 3 and len(bisector2) == 3:
		x1 = bisector1[0]
		y1 = bisector1[1]
		k1 = bisector1[2]
		x2 = bisector2[0]
		y2 = bisector2[1]
		k2 = bisector2[2]
		if abs(k1 - k2) < 10 ** (-4):
			return None
		x = (y2 - y1 + k1 * x1 - k2 * x2) / (k1 - k2)
		y = (k1 * k2 * (x2 - x1) + k2 * y1 - k1 * y2) / (k2 - k1)
		return (x, y)
	if len(bisector1) == 1 and len(bisector2) == 3:
		x1 = bisector1[0]
		x2 = bisector2[0]
		y2 = bisector2[1]
		k2 = bisector2[2]
		x = x1
		y = y2 + k2 * (x1 - x2)
		return (x, y)
	if len(bisector1) == 3 and len(bisector2) == 1:
		x1 = bisector1[0]
		y1 = bisector1[1]
		k1 = bisector1[2]
		x2 = bisector2[0]
		x = x2
		y = y1 + k1 * (x2 - x1)
		return (x, y)
	if len(bisector1) == 1 and len(bisector2) == 1:
		return None

def bisector_circle_intersection(b, c):
	x0 = c._Cx
	y0 = c._Cy
	r = c._r
	if len(b) == 1:
		x = b[0]
		if r ** 2 - (x - x0) ** 2 < 0:
			return None
		if r ** 2 - (x - x0) ** 2 == 0:
			return (x, y0)
		y1 = (r ** 2 - (x - x0) ** 2) ** 0.5 + y0
		y2 = -(r ** 2 - (x - x0) ** 2) ** 0.5 + y0
		return ((x, y1), (x, y2))
	l_k = b[2]
	l_b = b[1] - l_k * b[0]
	x1 = -(((l_k ** 2 + 1) * r ** 2 - x0 ** 2 * l_k ** 2 + (2 * x0 * y0 - 2 * l_b * x0) * l_k - y0 ** 2 + 2 * l_b * y0 - l_b ** 2) ** 0.5 + l_k * (l_b - y0) - x0) / (l_k ** 2 + 1)
	y1 = -(l_k * ((l_k ** 2 * r ** 2 + r ** 2 - x0 ** 2 * l_k ** 2 + 2 * x0 * y0 * l_k - 2 * l_b * x0 * l_k - y0 ** 2 + 2 * l_b * y0 - l_b ** 2) ** 0.5 - x0) - y0 * l_k ** 2 - l_b) / (l_k ** 2 + 1)
	x2 = (((l_k ** 2 + 1) * r ** 2 - x0 ** 2 * l_k ** 2 + (2 * x0 * y0 - 2 * l_b * x0) * l_k - y0 ** 2 + 2 * l_b * y0 - l_b ** 2) ** 0.5 - l_k * (l_b - y0) + x0) / (l_k ** 2 + 1)
	y2 = -(l_k * (-(l_k ** 2 * r ** 2 + r ** 2 - x0 ** 2 * l_k ** 2 + 2 * x0 * y0 * l_k - 2 * l_b * x0 * l_k - y0 ** 2 + 2 * l_b * y0 - l_b ** 2) ** 0.5 - x0) - y0 * l_k ** 2 - l_b) / (l_k ** 2 + 1)
	ans = []
	if type(x1) != complex and type(y1) != complex:
		ans.append((x1, y1))
	if type(x2) != complex and type(y2) != complex:
		ans.append((x2, y2))
	if ans != []:
		return ans
	return None
stadium_list = []
for _ in range(3):
	(x, y, r) = map(int, input().split())
	stadium_list.append(Circle(x, y, r))
apollonius_list = []
bisector_list = []
if stadium_list[0]._r / stadium_list[1]._r == 1:
	bisector_list.append(bisector(stadium_list[0]._Cx, stadium_list[0]._Cy, stadium_list[1]._Cx, stadium_list[1]._Cy))
else:
	apollonius_list.append(apollonius(stadium_list[0]._Cx, stadium_list[0]._Cy, stadium_list[1]._Cx, stadium_list[1]._Cy, stadium_list[0]._r / stadium_list[1]._r))
if stadium_list[1]._r / stadium_list[2]._r == 1:
	bisector_list.append(bisector(stadium_list[1]._Cx, stadium_list[1]._Cy, stadium_list[2]._Cx, stadium_list[2]._Cy))
else:
	apollonius_list.append(apollonius(stadium_list[1]._Cx, stadium_list[1]._Cy, stadium_list[2]._Cx, stadium_list[2]._Cy, stadium_list[1]._r / stadium_list[2]._r))
if stadium_list[2]._r / stadium_list[0]._r == 1:
	bisector_list.append(bisector(stadium_list[2]._Cx, stadium_list[2]._Cy, stadium_list[0]._Cx, stadium_list[0]._Cy))
else:
	apollonius_list.append(apollonius(stadium_list[2]._Cx, stadium_list[2]._Cy, stadium_list[0]._Cx, stadium_list[0]._Cy, stadium_list[2]._r / stadium_list[0]._r))
intersection_list = []

def add_circle_intersection(c1, c2):
	ans = circle_intersection(c1, c2)
	if ans != None:
		if type(ans[0]) == tuple:
			intersection_list.append(ans[0])
			intersection_list.append(ans[1])
		else:
			intersection_list.append(ans)

def add_bisector_intersection(b1, b2):
	ans = bisector_intersection(b1, b2)
	if ans != None:
		intersection_list.append(ans)

def add_bisector_circle_intersection(b, c):
	ans = bisector_circle_intersection(b, c)
	if ans != None:
		if type(ans[0]) == tuple:
			intersection_list.append(ans[0])
			intersection_list.append(ans[1])
		else:
			intersection_list.append(ans)
if len(apollonius_list) > 1:
	for (c1, c2) in itertools.combinations(apollonius_list, 2):
		add_circle_intersection(c1, c2)
if len(bisector_list) > 1:
	for (b1, b2) in itertools.combinations(bisector_list, 2):
		add_bisector_intersection(b1, b2)
if len(apollonius_list) > 0 and len(bisector_list) > 0:
	for c in apollonius_list:
		for b in bisector_list:
			add_bisector_circle_intersection(b, c)
if len(intersection_list) != 0:
	sinangle_list = [stadium_list[0]._r / ((stadium_list[0]._Cx - I[0]) ** 2 + (stadium_list[0]._Cy - I[1]) ** 2) ** 0.5 for I in intersection_list]
	index = sinangle_list.index(max(sinangle_list))
	print('%.6f %.6f' % (intersection_list[index][0], intersection_list[index][1]))


V = [list(map(int, input().split())) for _ in range(3)]
a = []
for i in range(3):
	da = V[i][0] - V[(i + 1) % 3][0]
	db = V[i][1] - V[(i + 1) % 3][1]
	drs = V[i][2] ** 2 - V[(i + 1) % 3][2] ** 2
	das = (V[i][0] + V[(i + 1) % 3][0]) * da
	dbs = (V[i][1] + V[(i + 1) % 3][1]) * db
	a.append([2 * da, 2 * db, drs, das + dbs])

def Gauss(n, m):
	for i in range(n - 1):
		Max = i
		for j in range(i, n):
			if a[j][i] > a[Max][i]:
				Max = j
		for j in range(m):
			(a[i][j], a[Max][j]) = (a[Max][j], a[i][j])
		if a[i][i] == 0:
			continue
		for j in range(i + 1, m):
			a[i][j] /= a[i][i]
		a[i][i] = 1
		for j in range(i + 1, n):
			tmp = a[j][i] / a[i][i]
			for k in range(i, m):
				a[j][k] -= tmp * a[i][k]
Gauss(3, 4)

def gett(x, y):
	a = V[0][0]
	b = V[0][1]
	r = V[0][2]
	A = x[0] ** 2 + y[0] ** 2
	B = 2 * x[0] * (x[1] - a) + 2 * y[0] * (y[1] - b) - r * r
	C = (x[1] - a) ** 2 + (y[1] - b) ** 2
	if A == 0:
		if B == 0:
			print()
			exit(0)
		else:
			return C / B
	delta = B ** 2 - 4 * A * C
	if delta < 0:
		print()
		exit(0)
	t1 = (-B + delta ** (1 / 2)) / (2 * A)
	t2 = (-B - delta ** (1 / 2)) / (2 * A)
	if min(t1, t2) > 0:
		return min(t1, t2)
	elif max(t1, t2) < 0:
		print()
		exit(0)
	else:
		return max(t1, t2)
if abs(a[2][2]) < 1e-07:
	if abs(a[2][3]) > 1e-07:
		print()
		exit(0)
	y = (-a[1][2], a[1][3])
	x = (-a[0][2] + a[0][1] * a[1][2], a[0][3] - a[0][1] * a[1][3])
	t = gett(x, y)
	y = -a[1][2] * t + a[1][3]
	x = (-a[0][2] + a[0][1] * a[1][2]) * t + a[0][3] - a[0][1] * a[1][3]
	print('%.5f %.5f' % (x, y))
else:
	t = a[2][3] / a[2][2]
	if a[1][1] == 0 and a[1][3] - a[1][2] * t != 0:
		print()
		exit(0)
	if a[1][1] == 0:
		y = 0
	else:
		y = (a[1][3] - a[1][2] * t) / a[1][1]
	if a[0][0] == 0 and a[0][3] - a[0][2] * t - a[0][1] * y != 0:
		print()
		exit(0)
	if a[0][0] == 0:
		x = 0
	else:
		x = (a[0][3] - a[0][2] * t - a[0][1] * y) / a[0][0]
	print('%.5f %.5f' % (x, y))


import math

def iline(p1, p2, a, b):
	(x1, y1) = p1
	(x2, y2) = p2
	x = (b * x1 + a * x2) / (a + b)
	y = (b * y1 + a * y2) / (a + b)
	return (x, y)

def oline(p1, p2, a, b):
	(x1, y1) = p1
	(x2, y2) = p2
	x = (b * x1 - a * x2) / (b - a)
	y = (b * y1 - a * y2) / (b - a)
	return (x, y)

def midp(p1, p2):
	return iline(p1, p2, 1, 1)

def dist(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def locus(c1, c2):
	(x1, y1, r1) = c1
	(x2, y2, r2) = c2
	ip = iline((x1, y1), (x2, y2), r1, r2)
	op = oline((x1, y1), (x2, y2), r1, r2)
	mp = midp(ip, op)
	r = dist(mp, ip)
	return (mp[0], mp[1], r)

def line(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	a = x1 - x2
	b = y1 - y2
	c = -(y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) / 2
	return (a, b, c)

def cvc(c1, c2):
	(x1, y1, r1) = c1
	(x2, y2, r2) = c2
	d = dist((x1, y1), (x2, y2))
	if d > r1 + r2:
		return 0
	elif d == 0 and r1 == r2:
		return -1
	elif d < abs(r1 - r2):
		return []
	elif d == r1 + r2:
		a = (r1 ** 2 - r2 ** 2 + d ** 2) / (2 * d)
		p2x = x1 + a * (x2 - x1) / d
		p2y = y1 + a * (y2 - y1) / d
		return [(p2x, p2y)]
	else:
		a = (r1 ** 2 - r2 ** 2 + d ** 2) / (2 * d)
		h = math.sqrt(r1 ** 2 - a ** 2)
		p2x = x1 + a * (x2 - x1) / d
		p2y = y1 + a * (y2 - y1) / d
		x31 = p2x + h * (y2 - y1) / d
		y31 = p2y - h * (x2 - x1) / d
		x32 = p2x - h * (y2 - y1) / d
		y32 = p2y + h * (x2 - x1) / d
		return [(x31, y31), (x32, y32)]

def linetr(a, b, c, x, y):
	c = c - a * x - b * y
	return (a, b, c)

def pointtr(a, b, x, y):
	return (a + x, b + y)

def cvl(c, l):
	(la, lb, lc) = l
	(x1, y1, r1) = c
	(la, lb, lc) = linetr(la, lb, lc, -x1, -y1)
	d0 = abs(lc) / math.sqrt(la ** 2 + lb ** 2)
	x = -(la * lc) / (la ** 2 + lb ** 2)
	y = -(lb * lc) / (la ** 2 + lb ** 2)
	if d0 > r1:
		return []
	elif d0 == r1:
		(x, y) = pointtr(x, y, x1, y1)
		return [(x, y)]
	else:
		d = r1 ** 2 - lc ** 2 / (la ** 2 + lb ** 2)
		m = math.sqrt(d / (la ** 2 + lb ** 2))
		ax = x + lb * m
		ay = y - la * m
		bx = x - lb * m
		by = y + la * m
		(ax, ay) = pointtr(ax, ay, x1, y1)
		(bx, by) = pointtr(bx, by, x1, y1)
		return [(ax, ay), (bx, by)]

def lvl(l1, l2):
	(a1, b1, c1) = l1
	(a2, b2, c2) = l2
	if b1 != 0 and b2 != 0:
		if a1 / b1 == a2 / b2:
			if c1 / b1 == c2 / b2:
				return -1
			else:
				return []
		else:
			x = (c1 * b2 - b1 * c2) / (b1 * a2 - a1 * b2)
			y = (c2 * a1 - c1 * a2) / (b1 * a2 - a1 * b2)
			return [(x, y)]
	else:
		x = (c1 * b2 - b1 * c2) / (b1 * a2 - a1 * b2)
		y = (c2 * a1 - c1 * a2) / (b1 * a2 - a1 * b2)
		return [(x, y)]

def main():
	c1 = tuple(map(int, input().split()))
	c2 = tuple(map(int, input().split()))
	c3 = tuple(map(int, input().split()))
	(line1, line2, circ1, circ2) = (False, False, False, False)
	if c1[2] == c2[2]:
		line1 = line(c1[:2], c2[:2])
	else:
		circ1 = locus(c1, c2)
	if c2[2] == c3[2]:
		line2 = line(c2[:2], c3[:2])
	else:
		circ2 = locus(c2, c3)
	if c1[2] == c3[2]:
		line3 = line(c1[:2], c3[:2])
	else:
		circ3 = locus(c1, c3)
	if circ1 and circ2:
		ans = cvc(circ1, circ2)
	elif circ1 and line2:
		ans = cvl(circ1, line2)
	elif circ2 and line1:
		ans = cvl(circ2, line1)
	elif line1 and line2:
		ans = lvl(line1, line2)
	temp = []
	if not ans:
		return
	else:
		for (x, y) in ans:
			angle = 2 * math.asin(c1[2] / dist((x, y), (c1[0], c1[1])))
			temp.append((x, y, angle))
		ans = sorted(temp, key=lambda x: x[2], reverse=True)
		print('{:.6f} {:.6f}'.format(ans[0][0], ans[0][1]))
		return
main()


import math

def winner(x):
	scores = {}
	for i in range(len(x)):
		if x[i][0] in scores:
			scores[x[i][0]] += x[i][1]
		else:
			scores[x[i][0]] = x[i][1]
	s = max(scores.values())
	ss = []
	for i in scores:
		if s == scores[i]:
			ss.append(i)
	if len(ss) == 1:
		return ss[0]
	cscores = {}
	for i in ss:
		cscores[i] = 0
	scores = {}
	for i in range(len(x)):
		if x[i][0] in cscores:
			cscores[x[i][0]] += x[i][1]
			if cscores[x[i][0]] >= s:
				return x[i][0]

def findcommentator(A, B, C):
	bLine = A[2] == C[2]
	cLine = A[2] == B[2]
	a = (B[0] - C[0]) ** 2 + (B[1] - C[1]) ** 2
	b = (A[0] - C[0]) ** 2 + (A[1] - C[1]) ** 2
	c = (B[0] - A[0]) ** 2 + (B[1] - A[1]) ** 2
	if bLine and cLine:
		x = (a * (b + c - a) * A[0] + b * (a + c - b) * B[0] + c * (b + a - c) * C[0]) / (a * (b + c - a) + b * (a + c - b) + c * (b + a - c))
		y = (a * (b + c - a) * A[1] + b * (a + c - b) * B[1] + c * (b + a - c) * C[1]) / (a * (b + c - a) + b * (a + c - b) + c * (b + a - c))
		return (x, y)
	a = math.sqrt(a)
	b = math.sqrt(b)
	c = math.sqrt(c)
	if bLine:
		D = [C[0] - A[0], C[1] - A[1], (A[0] ** 2 + A[1] ** 2 - C[0] ** 2 - C[1] ** 2) / 2]
		C1 = [(A[2] ** 2 * B[0] - B[2] ** 2 * A[0]) / (A[2] ** 2 - B[2] ** 2), (A[2] ** 2 * B[1] - B[2] ** 2 * A[1]) / (A[2] ** 2 - B[2] ** 2), abs(A[2] * B[2] * c / (A[2] ** 2 - B[2] ** 2))]
		d = -1 * (D[0] * C1[0] + D[1] * C1[1] + D[2]) / math.sqrt(D[0] ** 2 + D[1] ** 2)
		F = [C1[0] + D[0] * d / math.sqrt(D[0] ** 2 + D[1] ** 2), C1[1] + D[1] * d / math.sqrt(D[0] ** 2 + D[1] ** 2)]
		if d < C1[2]:
			x = math.sqrt(C1[2] ** 2 - d ** 2)
			l = math.sqrt(D[0] ** 2 + D[1] ** 2)
			P1 = [F[0] + x * D[1] / l, F[1] - x * D[0] / l]
			P2 = [F[0] - x * D[1] / l, F[1] + x * D[0] / l]
			if (P1[0] - A[0]) ** 2 + (P1[1] - A[1]) ** 2 > (P2[0] - A[0]) ** 2 + (P2[1] - A[1]) ** 2:
				return (P2[0], P2[1])
			else:
				return (P1[0], P1[1])
	elif cLine:
		D = [B[0] - A[0], B[1] - A[1], (A[0] ** 2 + A[1] ** 2 - B[0] ** 2 - B[1] ** 2) / 2]
		C1 = [(A[2] ** 2 * C[0] - C[2] ** 2 * A[0]) / (A[2] ** 2 - C[2] ** 2), (A[2] ** 2 * C[1] - C[2] ** 2 * A[1]) / (A[2] ** 2 - C[2] ** 2), abs(A[2] * C[2] * b / (A[2] ** 2 - C[2] ** 2))]
		d = -1 * (D[0] * C1[0] + D[1] * C1[1] + D[2]) / math.sqrt(D[0] ** 2 + D[1] ** 2)
		F = [C1[0] + D[0] * d / math.sqrt(D[0] ** 2 + D[1] ** 2), C1[1] + D[1] * d / math.sqrt(D[0] ** 2 + D[1] ** 2)]
		if d < C1[2]:
			x = math.sqrt(C1[2] ** 2 - d ** 2)
			l = math.sqrt(D[0] ** 2 + D[1] ** 2)
			P1 = [F[0] + x * D[1] / l, F[1] - x * D[0] / l]
			P2 = [F[0] - x * D[1] / l, F[1] + x * D[0] / l]
			if (P1[0] - A[0]) ** 2 + (P1[1] - A[1]) ** 2 > (P2[0] - A[0]) ** 2 + (P2[1] - A[1]) ** 2:
				return (P2[0], P2[1])
			else:
				return (P1[0], P1[1])
	else:
		C1 = [(A[2] ** 2 * B[0] - B[2] ** 2 * A[0]) / (A[2] ** 2 - B[2] ** 2), (A[2] ** 2 * B[1] - B[2] ** 2 * A[1]) / (A[2] ** 2 - B[2] ** 2), abs(A[2] * B[2] * c / (A[2] ** 2 - B[2] ** 2))]
		C2 = [(A[2] ** 2 * C[0] - C[2] ** 2 * A[0]) / (A[2] ** 2 - C[2] ** 2), (A[2] ** 2 * C[1] - C[2] ** 2 * A[1]) / (A[2] ** 2 - C[2] ** 2), abs(A[2] * C[2] * b / (A[2] ** 2 - C[2] ** 2))]
		d = math.sqrt((C1[0] - C2[0]) ** 2 + (C1[1] - C2[1]) ** 2)
		if d <= C1[2] + C2[2]:
			k = 0.5 * (C1[2] ** 2 - C2[2] ** 2) / d ** 2
			P = [0.5 * (C1[0] + C2[0]) + k * (C2[0] - C1[0]), 0.5 * (C1[1] + C2[1]) + k * (C2[1] - C1[1])]
			P1 = [0, 0]
			P2 = [0, 0]
			if 2 * (C1[2] ** 2 + C2[2] ** 2) / d ** 2 - (C1[2] ** 2 - C2[2] ** 2) ** 2 / d ** 4 - 1 < 0:
				return None
			k = 0.5 * math.sqrt(2 * (C1[2] ** 2 + C2[2] ** 2) / d ** 2 - (C1[2] ** 2 - C2[2] ** 2) ** 2 / d ** 4 - 1)
			P1[0] = P[0] + k * (C2[1] - C1[1])
			P2[0] = P[0] - k * (C2[1] - C1[1])
			P1[1] = P[1] + k * (C1[0] - C2[0])
			P2[1] = P[1] - k * (C1[0] - C2[0])
			if (P1[0] - A[0]) ** 2 + (P1[1] - A[1]) ** 2 > (P2[0] - A[0]) ** 2 + (P2[1] - A[1]) ** 2:
				return (P2[0], P2[1])
			else:
				return (P1[0], P1[1])
A = list(map(float, input().split()))
B = list(map(float, input().split()))
C = list(map(float, input().split()))
D = findcommentator(A, B, C)
if D != None:
	print(*D)


def diff(x):
	d = []
	for (y, ry) in circles:
		d.append(abs(x - y) / ry)
	ans = 0
	for i in range(3):
		ans += (d[i] - d[(i + 1) % 1]) ** 2
	return ans

def hill_climbing(circles):
	x = 0
	s = 1
	for (y, _) in circles:
		x += y / 3
	while s > 1e-06:
		d0 = diff(x)
		if d0 > diff(x + s):
			x += s
		elif d0 > diff(x - s):
			x -= s
		elif d0 > diff(x + s * 1j):
			x += s * 1j
		elif d0 > diff(x - s * 1j):
			x -= s * 1j
		else:
			s *= 0.5
	return x if diff(x) < 1e-05 else None
circles = []
for _ in range(3):
	(x, y, r) = map(int, input().split())
	circles.append((x + y * 1j, r))
answer = hill_climbing(circles)
if answer is not None:
	print('{:.5f} {:.5f}'.format(answer.real, answer.imag))


import math

def calCircle(x1, y1, r1, x2, y2, r2):
	inner = (x1 + r1 / (r1 + r2) * (x2 - x1), y1 + r1 / (r1 + r2) * (y2 - y1))
	outer = ((r2 * x1 - r1 * x2) / (r2 - r1), (r2 * y1 - r1 * y2) / (r2 - r1))
	centre = ((inner[0] + outer[0]) / 2, (inner[1] + outer[1]) / 2)
	radius = ((inner[0] - centre[0]) ** 2 + (inner[1] - centre[1]) ** 2) ** 0.5
	return (centre, radius)
(x1, y1, r1) = map(float, input().split(' '))
(x2, y2, r2) = map(float, input().split(' '))
(x3, y3, r3) = map(float, input().split(' '))
if r1 == r2 and r1 == r3:
	(a, b, c, d) = (x1 - x2, y1 - y2, x1 - x3, y1 - y3)
	e = (x1 * x1 - x2 * x2 + (y1 * y1 - y2 * y2)) / 2
	f = (x1 * x1 - x3 * x3 + (y1 * y1 - y3 * y3)) / 2
	x = -(d * e - b * f) / (b * c - a * d)
	y = -(a * f - c * e) / (b * c - a * d)
elif r1 == r2:
	(a, b, c) = (x1 - x2, y1 - y2, (x1 * x1 - x2 * x2 + (y1 * y1 - y2 * y2)) / 2)
	(centre, radius) = calCircle(x1, y1, r1, x3, y3, r3)
	p = 1 + a * a / (b * b)
	q = 2 * (centre[1] - c / b) * a / b - 2 * centre[0]
	r = centre[0] ** 2 + (centre[1] - c / b) ** 2 - radius * radius
	delta = q * q - 4 * p * r
	(px1, px2) = ((-q + math.sqrt(delta)) / (2 * p), (-q - math.sqrt(delta)) / (2 * p))
	(py1, py2) = ((c - a * px1) / b, (c - a * px2) / b)
	norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
	norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
	if r1 / norm1 > r1 / norm2:
		(x, y) = (px1, py1)
	else:
		(x, y) = (px2, py2)
elif r1 == r3:
	(a, b, c) = (x1 - x3, y1 - y3, (x1 * x1 - x3 * x3 + (y1 * y1 - y3 * y3)) / 2)
	(centre, radius) = calCircle(x1, y1, r1, x2, y2, r2)
	p = 1 + a * a / (b * b)
	q = 2 * (centre[1] - c / b) * a / b - 2 * centre[0]
	r = centre[0] ** 2 + (centre[1] - c / b) ** 2 - radius * radius
	delta = q * q - 4 * p * r
	(px1, px2) = ((-q + math.sqrt(delta)) / (2 * p), (-q - math.sqrt(delta)) / (2 * p))
	(py1, py2) = ((c - a * px1) / b, (c - a * px2) / b)
	norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
	norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
	if r1 / norm1 > r1 / norm2:
		(x, y) = (px1, py1)
	else:
		(x, y) = (px2, py2)
else:
	(centre1, radius1) = calCircle(x1, y1, r1, x2, y2, r2)
	(centre2, radius2) = calCircle(x1, y1, r1, x3, y3, r3)
	d = math.sqrt((centre1[0] - centre2[0]) ** 2 + (centre1[1] - centre2[1]) ** 2)
	l = (radius1 ** 2 - radius2 ** 2 + d ** 2) / (2 * d)
	if radius1 ** 2 - l ** 2 < 0:
		exit()
	h = math.sqrt(radius1 ** 2 - l ** 2)
	px1 = l / d * (centre2[0] - centre1[0]) + h / d * (centre2[1] - centre1[1]) + centre1[0]
	px2 = l / d * (centre2[0] - centre1[0]) - h / d * (centre2[1] - centre1[1]) + centre1[0]
	py1 = l / d * (centre2[1] - centre1[1]) - h / d * (centre2[0] - centre1[0]) + centre1[1]
	py2 = l / d * (centre2[1] - centre1[1]) + h / d * (centre2[0] - centre1[0]) + centre1[1]
	norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
	norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
	if r1 / norm1 > r1 / norm2:
		(x, y) = (px1, py1)
	else:
		(x, y) = (px2, py2)
print(x, y)


def main():
	import math

	def calCircle(x1, y1, r1, x2, y2, r2):
		inner = (x1 + r1 / (r1 + r2) * (x2 - x1), y1 + r1 / (r1 + r2) * (y2 - y1))
		outer = ((r2 * x1 - r1 * x2) / (r2 - r1), (r2 * y1 - r1 * y2) / (r2 - r1))
		centre = ((inner[0] + outer[0]) / 2, (inner[1] + outer[1]) / 2)
		radius = ((inner[0] - centre[0]) ** 2 + (inner[1] - centre[1]) ** 2) ** 0.5
		return (centre, radius)
	(x1, y1, r1) = map(float, input().split(' '))
	(x2, y2, r2) = map(float, input().split(' '))
	(x3, y3, r3) = map(float, input().split(' '))
	if r1 == r2 and r1 == r3:
		(a, b, c, d) = (x1 - x2, y1 - y2, x1 - x3, y1 - y3)
		e = (x1 * x1 - x2 * x2 + (y1 * y1 - y2 * y2)) / 2
		f = (x1 * x1 - x3 * x3 + (y1 * y1 - y3 * y3)) / 2
		x = -(d * e - b * f) / (b * c - a * d)
		y = -(a * f - c * e) / (b * c - a * d)
	elif r1 == r2:
		(a, b, c) = (x1 - x2, y1 - y2, (x1 * x1 - x2 * x2 + (y1 * y1 - y2 * y2)) / 2)
		(centre, radius) = calCircle(x1, y1, r1, x3, y3, r3)
		p = 1 + a * a / (b * b)
		q = 2 * (centre[1] - c / b) * a / b - 2 * centre[0]
		r = centre[0] ** 2 + (centre[1] - c / b) ** 2 - radius * radius
		delta = q * q - 4 * p * r
		(px1, px2) = ((-q + math.sqrt(delta)) / (2 * p), (-q - math.sqrt(delta)) / (2 * p))
		(py1, py2) = ((c - a * px1) / b, (c - a * px2) / b)
		norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
		norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
		if r1 / norm1 > r1 / norm2:
			(x, y) = (px1, py1)
		else:
			(x, y) = (px2, py2)
	elif r1 == r3:
		(a, b, c) = (x1 - x3, y1 - y3, (x1 * x1 - x3 * x3 + (y1 * y1 - y3 * y3)) / 2)
		(centre, radius) = calCircle(x1, y1, r1, x2, y2, r2)
		p = 1 + a * a / (b * b)
		q = 2 * (centre[1] - c / b) * a / b - 2 * centre[0]
		r = centre[0] ** 2 + (centre[1] - c / b) ** 2 - radius * radius
		delta = q * q - 4 * p * r
		(px1, px2) = ((-q + math.sqrt(delta)) / (2 * p), (-q - math.sqrt(delta)) / (2 * p))
		(py1, py2) = ((c - a * px1) / b, (c - a * px2) / b)
		norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
		norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
		if r1 / norm1 > r1 / norm2:
			(x, y) = (px1, py1)
		else:
			(x, y) = (px2, py2)
	else:
		(centre1, radius1) = calCircle(x1, y1, r1, x2, y2, r2)
		(centre2, radius2) = calCircle(x1, y1, r1, x3, y3, r3)
		d = math.sqrt((centre1[0] - centre2[0]) ** 2 + (centre1[1] - centre2[1]) ** 2)
		l = (radius1 ** 2 - radius2 ** 2 + d ** 2) / (2 * d)
		if radius1 ** 2 - l ** 2 < 0:
			exit()
		h = math.sqrt(radius1 ** 2 - l ** 2)
		px1 = l / d * (centre2[0] - centre1[0]) + h / d * (centre2[1] - centre1[1]) + centre1[0]
		px2 = l / d * (centre2[0] - centre1[0]) - h / d * (centre2[1] - centre1[1]) + centre1[0]
		py1 = l / d * (centre2[1] - centre1[1]) - h / d * (centre2[0] - centre1[0]) + centre1[1]
		py2 = l / d * (centre2[1] - centre1[1]) + h / d * (centre2[0] - centre1[0]) + centre1[1]
		norm1 = ((px1 - x1) ** 2 + (py1 - y1) ** 2) ** 0.5
		norm2 = ((px2 - x1) ** 2 + (py2 - y1) ** 2) ** 0.5
		if r1 / norm1 > r1 / norm2:
			(x, y) = (px1, py1)
		else:
			(x, y) = (px2, py2)
	print(x, y)
import sys, io, os
BUFSIZE = 8192

class FastIO(io.IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = io.BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(io.IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	for x in args:
		file.write(str(x))
	file.write(kwargs.pop('end', '\n'))
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
inputt = lambda t=0: range(t) if t else range(int(input()))
inputi = lambda : map(int, input().split())
inputl = lambda : list(inputi())
from math import *
from heapq import *
from bisect import *
from itertools import *
from functools import reduce, lru_cache
from collections import Counter, defaultdict
import re, copy, operator, cmath
from builtins import *
main()