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

Solution:
from math import sqrt

PREC = 0.00005

def testLine(m, b, c1x, c1y, r1, c2x, c2y, r2):
	if m is None:
		x = b
		y1, y2, y3 = 0.0, 1.0, -1.0
		assert floatEq(getAngleSin(x, y1, c1x, c1y, r1), getAngleSin(x, y1, c2x, c2y, r2))
		assert floatEq(getAngleSin(x, y2, c1x, c1y, r1), getAngleSin(x, y2, c2x, c2y, r2))
		assert floatEq(getAngleSin(x, y3, c1x, c1y, r1), getAngleSin(x, y3, c2x, c2y, r2))
		return
	x1, x2, x3 = 0.0, 1.0, -1.0
	y1, y2, y3 = m*x1+b, m*x2+b, m*x3+b
	assert floatEq(getAngleSin(x1, y1, c1x, c1y, r1), getAngleSin(x1, y1, c2x, c2y, r2))
	assert floatEq(getAngleSin(x2, y2, c1x, c1y, r1), getAngleSin(x2, y2, c2x, c2y, r2))
	assert floatEq(getAngleSin(x3, y3, c1x, c1y, r1), getAngleSin(x3, y3, c2x, c2y, r2))

def testCircle(r, cx, cy, c1x, c1y, r1, c2x, c2y, r2):
	assert floatEq(getAngleSin(cx, cy+r, c1x, c1y, r1), getAngleSin(cx, cy+r, c2x, c2y, r2))
	assert floatEq(getAngleSin(cx, cy-r, c1x, c1y, r1), getAngleSin(cx, cy-r, c2x, c2y, r2))
	assert floatEq(getAngleSin(cx+r, cy, c1x, c1y, r1), getAngleSin(cx+r, cy, c2x, c2y, r2))
	assert floatEq(getAngleSin(cx-r, cy, c1x, c1y, r1), getAngleSin(cx-r, cy, c2x, c2y, r2))
	
def floatEq(x, y):
	return abs(x-y) < PREC
	
def getDist(x1, y1, x2, y2):
	return sqrt((x1-x2)**2 + (y1-y2)**2)
	
def getAngleSin(x, y, cx, cy, r):
	s = getDist(x, y, cx, cy)
	res = r/s
	# print(res)
	return res
	
def getLine(c1x, c1y, r1, c2x, c2y, r2):
	px = (c1x+c2x)/2.0
	py = (c1y+c2y)/2.0
	dx = c1x-c2x
	dy = c1y-c2y
	if dy == 0:
		m = None #Vertical
		return m, px
	if dx == 0:
		m = 0.0
		return m, py
	m = -float(dx)/dy
	b = py - m*px
	return m, b
	
def getCircle(c1x, c1y, r1, c2x, c2y, r2):
	if r2 < r1:
		r1, r2 = r2, r1
		c1x, c2x = c2x, c1x
		c1y, c2y = c2y, c1y
	r1, r2, c1x, c1y, c2x, c2y = float(r1), float(r2), float(c1x), float(c1y), float(c2x), float(c2y)
	k = r1/r2
	# c1x = -1.
	# c1y = 0.
	# c2x = 0.
	# c2y = 2.
	# k = 3.0
	alpha = 1 - k**2
	betaX = 2*(c2x*(k**2) - c1x)/alpha
	betaY = 2*(c2y*(k**2) - c1y)/alpha
	gamma = ((k**2)*(c2x**2 + c2y**2) - (c1x**2 + c1y**2))/alpha
	gammaP = gamma + (betaX**2)/4 + (betaY**2)/4
	rP = sqrt(gammaP)
	cPx = -betaX/2
	cPy = -betaY/2
	
	# print(rP, cPx, cPy)
	# print("aaaaaaaaaaaa")
	# print(getDist(cPx+rP, cPy, c1x, c1y), getDist(cPx+rP, cPy, c2x, c2y))
	
	# s = getDist(c1x, c1y, c2x, c2y)
	# d1 = s/(1+k)
	# d2 = s/(1-k)
	# rP = (d2-d1)/2
	# cPx = c2x + (c1x-c2x)*(1/(1+k) + 1/(1-k))/2
	# cPy = c2y + (c1y-c2y)*(1/(1+k) + 1/(1-k))/2
	return rP, cPx, cPy
	
def getLineLine(m1, b1, m2, b2):
	if m1 is None and m2 is None:
		assert not floatEq(b1, b2)
		return []
	if m1 is None:
		x = b1
		y = m2*x+b2
		return [(x, y)]
	if m2 is None:
		x = b2
		y = m1*x+b1
		return [(x, y)]
	if floatEq(m1, m2):
		assert not floatEq(b1, b2)
		return []
	x = (b2-b1)/(m1-m2)
	y = m1*x + b1
	return [(x, y)]
	
def getLineCircle(m, b, r, cx, cy):
	if m is None:
		if r < abs(b-cx):
			return []
		elif floatEq(r, abs(b-cx)):
			return [(b, cy)]
		d = sqrt(r**2-(b-cx)**2)
		y1, y2 = cy+d, cy-d
		return [(b, y1), (b, y2)]
	elif floatEq(m, 0.0):
		if r < abs(b-cy):
			return []
		elif floatEq(r, abs(b-cy)):
			return [(cx, b)]
		d = sqrt(r**2-(b-cy)**2)
		x1, x2 = cx+d, cx-d
		return [(x1, b), (x2, b)]
	aQ = 1 + m**2
	bQ = 2*(m*(b-cy)-cx)
	cQ = cx**2 + (b-cy)**2 - r**2
	d = bQ**2 - 4*aQ*cQ
	if d < 0:
		return []
	if floatEq(d, 0.0):
		x = -bQ/(2*aQ)
		y = m*x + b
		return [(x, y)]
	d = sqrt(d)
	x1, x2 = (-bQ-d)/(2*aQ), (-bQ+d)/(2*aQ)
	y1, y2 = m*x1 + b, m*x2 + b
	return [(x1, y1), (x2, y2)]
	
def getCircleCircle(r1, c1x, c1y, r2, c2x, c2y):
	q = (r1**2 - c1x**2 - c1y**2 - r2**2 + c2x**2 + c2y**2)/2.0
	dx = c2x - c1x
	dy = c2y - c1y
	if floatEq(dy, 0.0) and floatEq(dx, 0.0):
		assert not floatEq(r1, r2)
		return []
	if floatEq(dy, 0.0):
		m = None
		b = q/dx
		return getLineCircle(m, b, r1, c1x, c1y)
	if floatEq(dx, 0.0):
		m = 0.0
		b = q/dy
		return getLineCircle(m, b, r1, c1x, c1y)
	m = -dx/dy
	b = q/dy
	return getLineCircle(m, b, r1, c1x, c1y)
	
def solve(c1x, c1y, r1, c2x, c2y, r2, c3x, c3y, r3):
	if r1 == r2:
		line12 = True
		ml12, bl12 = getLine(c1x, c1y, r1, c2x, c2y, r2)
		# print(ml12, bl12)
		testLine(ml12, bl12, c1x, c1y, r1, c2x, c2y, r2)
	else:
		line12 = False
		rl12, cl12x, cl12y = getCircle(c1x, c1y, r1, c2x, c2y, r2)
		# print(rl12, cl12x, cl12y)
		testCircle(rl12, cl12x, cl12y, c1x, c1y, r1, c2x, c2y, r2)
	if r1 == r3:
		line13 = True
		ml13, bl13 = getLine(c1x, c1y, r1, c3x, c3y, r3)
		# print(ml13, bl13)
		testLine(ml13, bl13, c1x, c1y, r1, c3x, c3y, r3)
	else:
		line13 = False
		rl13, cl13x, cl13y = getCircle(c1x, c1y, r1, c3x, c3y, r3)
		# print(rl13, cl13x, cl13y)
		testCircle(rl13, cl13x, cl13y, c1x, c1y, r1, c3x, c3y, r3)
	if r2 == r3:
		line23 = True
		ml23, bl23 = getLine(c2x, c2y, r2, c3x, c3y, r3)
		# print(ml23, bl23)
		testLine(ml23, bl23, c2x, c2y, r2, c3x, c3y, r3)
	else:
		line23 = False
		rl23, cl23x, cl23y = getCircle(c2x, c2y, r2, c3x, c3y, r3)
		# print(rl23, cl23x, cl23y)
		testCircle(rl23, cl23x, cl23y, c2x, c2y, r2, c3x, c3y, r3)
		
	if line12 and line13:
		rLst1 = getLineLine(ml12, bl12, ml13, bl13)
	elif line12 and not line13:
		rLst1 = getLineCircle(ml12, bl12, rl13, cl13x, cl13y)
	elif not line12 and line13:
		rLst1 = getLineCircle(ml13, bl13, rl12, cl12x, cl12y)
	elif not line12 and not line13:
		rLst1 = getCircleCircle(rl12, cl12x, cl12y, rl13, cl13x, cl13y)

	if line12 and line23:
		rLst2 = getLineLine(ml12, bl12, ml23, bl23)
	elif line12 and not line23:
		rLst2 = getLineCircle(ml12, bl12, rl23, cl23x, cl23y)
	elif not line12 and line23:
		rLst2 = getLineCircle(ml23, bl23, rl12, cl12x, cl12y)
	elif not line12 and not line23:
		rLst2 = getCircleCircle(rl12, cl12x, cl12y, rl23, cl23x, cl23y)
	
	if line13 and line23:
		rLst3 = getLineLine(ml13, bl13, ml23, bl23)
	elif line13 and not line23:
		rLst3 = getLineCircle(ml13, bl13, rl23, cl23x, cl23y)
	elif not line13 and line23:
		rLst3 = getLineCircle(ml23, bl23, rl13, cl13x, cl13y)
	elif not line13 and not line23:
		rLst3 = getCircleCircle(rl13, cl13x, cl13y, rl23, cl23x, cl23y)
		
	# print(rLst1)
	# print(rLst2)
	# print(rLst3)
	rLst12 = []
	for p in rLst1:
		for q in rLst2:
			if floatEq(p[0], q[0]) and floatEq(p[1], q[1]):
				rLst12.append(((p[0]+q[0])/2.0, (p[1]+q[1])/2.0))
	resLst = []
	for p in rLst12:
		for q in rLst3:
			if floatEq(p[0], q[0]) and floatEq(p[1], q[1]):
				resLst.append(((p[0]+q[0])/2.0, (p[1]+q[1])/2.0))
	if len(resLst) == 0:
		return None
	if len(resLst) == 1:
		return resLst[0]
	maxAngle = 0.0
	maxX, maxY = 0.0, 0.0
	for p in resLst:
		x, y = p
		angle = getAngleSin(x, y, c1x, c1y, r1)
		if angle > maxAngle:
			maxAngle = angle
			maxX = x
			maxY = y
	return (maxX, maxY)

c1x, c1y, r1 = [int(x) for x in raw_input().split()]
c2x, c2y, r2 = [int(x) for x in raw_input().split()]
c3x, c3y, r3 = [int(x) for x in raw_input().split()]
r = solve(c1x, c1y, r1, c2x, c2y, r2, c3x, c3y, r3)
if r is not None:
	x, y = r
	print("{:.5f}".format(x)+" "+"{:.5f}".format(y))