Fifa and Fafa are sharing a flat. Fifa loves video games and wants to download a new soccer game. Unfortunately, Fafa heavily uses the internet which consumes the quota. Fifa can access the internet through his Wi-Fi access point. This access point can be accessed within a range of r meters (this range can be chosen by Fifa) from its position. Fifa must put the access point inside the flat which has a circular shape of radius R. Fifa wants to minimize the area that is not covered by the access point inside the flat without letting Fafa or anyone outside the flat to get access to the internet.

The world is represented as an infinite 2D plane. The flat is centered at (x_1, y_1) and has radius R and Fafa's laptop is located at (x_2, y_2), not necessarily inside the flat. Find the position and the radius chosen by Fifa for his access point which minimizes the uncovered area.


-----Input-----

The single line of the input contains 5 space-separated integers R, x_1, y_1, x_2, y_2 (1 ≤ R ≤ 10^5, |x_1|, |y_1|, |x_2|, |y_2| ≤ 10^5).


-----Output-----

Print three space-separated numbers x_{ap}, y_{ap}, r where (x_{ap}, y_{ap}) is the position which Fifa chose for the access point and r is the radius of its range. 

Your answer will be considered correct if the radius does not differ from optimal more than 10^{ - 6} absolutely or relatively, and also the radius you printed can be changed by no more than 10^{ - 6} (absolutely or relatively) in such a way that all points outside the flat and Fafa's laptop position are outside circle of the access point range.


-----Examples-----
Input
5 3 3 1 1

Output
3.7677669529663684 3.7677669529663684 3.914213562373095

Input
10 5 5 5 15

Output
5.0 5.0 10.0

Difficulty: MEDIUM_HARD
Tags: Geometry

Starter code:

Solutions:
first = [float(x) for x in input().split(' ')]
(R, x1, y1, x2, y2) = (first[0], first[1], first[2], first[3], first[4])
x_f2c = x1 - x2
y_f2c = y1 - y2
dist = (x_f2c ** 2 + y_f2c ** 2) ** 0.5
if dist >= R:
	print(x1, y1, R)
else:
	new_R = (R + dist) / 2
	if x_f2c == 0 and y_f2c == 0:
		print(x1, y2 + 0.5 * R, 0.5 * R)
	else:
		(u_x, u_y) = (x_f2c / dist, y_f2c / dist)
		new_x = x2 + new_R * u_x
		new_y = y2 + new_R * u_y
		print(new_x, new_y, new_R)


(r, x1, y1, x2, y2) = map(int, input().split())

def dist(x1, x2, y1, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
rr = dist(x1, x2, y1, y2)
if rr >= r:
	print(x1, y1, r)
elif rr == 0:
	rrr = r / 2
	it = x2 + rrr
	itt = y2
	print(it, itt, rrr)
else:
	rrr = (rr + r) / 2
	it = x2 + (x1 - x2) * rrr / rr
	itt = y2 + (y1 - y2) * rrr / rr
	print(it, itt, rrr)


from math import sqrt
from typing import List, Tuple

def find_distance(x1: int, y1: int, x2: int, y2: int) -> float:
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def solve(R: int, x1: int, y1: int, x2: int, y2: int) -> Tuple[float, float, float]:
	ab = find_distance(x1, y1, x2, y2)
	if ab >= R:
		return (x1, y1, R)
	elif ab == 0:
		return (x1 + R / 2, y1, R / 2)
	s = (ab + R) / 2
	Xap = s * (x1 - x2) / ab + x2
	Yap = s * (y1 - y2) / ab + y2
	return (Xap, Yap, s)

def parse_input() -> List[int]:
	return [int(x) for x in input().split()]
(R, x1, y1, x2, y2) = parse_input()
print(' '.join((str(x) for x in solve(R, x1, y1, x2, y2))))


from math import sqrt
(r, x1, y1, x2, y2) = map(int, input().split())
l = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if l > r:
	print(x1, y1, r)
elif l:
	new_r = (r + l) / 2
	k = new_r / l - 1
	print(x1 + (x1 - x2) * k, y1 + (y1 - y2) * k, new_r)
else:
	new_r = r / 2
	print(x1 + new_r, y1, new_r)


def dist2(x1, y1, x2, y2):
	return (x1 - x2) ** 2 + (y1 - y2) ** 2
(R, x1, y1, x2, y2) = map(int, input().split())
if dist2(x1, y1, x2, y2) >= R ** 2:
	print(x1, y1, R)
else:
	d2 = dist2(x1, y1, x2, y2)
	if abs(d2) < 1e-10:
		x = x1 + R / 2
		y = y1
		print(x, y, R / 2)
	else:
		dd = d2 ** 0.5 + R
		dd /= 2
		x = x2 + dd * (x1 - x2) / d2 ** 0.5
		y = y2 + dd * (y1 - y2) / d2 ** 0.5
		print(x, y, dd)


import math
(R, x1, y1, x2, y2) = input().split()
Rc = float(R)
xc = float(x1)
yc = float(y1)
xp = float(x2)
yp = float(y2)

def points(Rc, xc, yc, xp, yp):
	if math.pow(xc - xp, 2) + math.pow(yc - yp, 2) >= math.pow(Rc, 2):
		return (xc, yc, Rc)
	elif not math.sqrt(math.pow(xc - xp, 2) + math.pow(yc - yp, 2)):
		return (xc + Rc / 2, yc, Rc / 2)
	dis = math.sqrt(math.pow(xc - xp, 2) + math.pow(yc - yp, 2))
	Rw = (dis + Rc) / 2
	xw = xp + (xc - xp) / dis * Rw
	yw = yp + (yc - yp) / dis * Rw
	return (xw, yw, Rw)
(xw, yw, Rw) = points(Rc, xc, yc, xp, yp)
print(xw, yw, Rw)


import math
(R, x1, y1, x2, y2) = map(int, input().split())
x = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if x > R:
	print(x1, y1, R)
elif x == 0:
	print(x1 + R / 2, y1, R / 2)
else:
	x3 = x2 + (x1 - x2) * ((R + x) / 2) / x
	y3 = y2 + (y1 - y2) * (R + x) / 2 / x
	print(x3, y3, (R + x) / 2)


import sys
import math
(R, x1, y1, x2, y2) = [int(num) for num in input().split(' ')]
if (x2 - x1) ** 2 + (y2 - y1) ** 2 > R ** 2:
	print(x1, y1, R)
	sys.exit()
if x1 == x2 and y2 == y1:
	print(x1 + R / 2, y1, R / 2)
	sys.exit()
ext = float(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** (1 / 2))
r = (ext + R) / 2
(xr, yr) = (x2 - (x2 - x1) * r / ext, y2 - (y2 - y1) * r / ext)
print(xr, yr, r)


(r1, x1, y1, x2, y2) = map(int, input().split())
if x1 == x2 and y1 == y2:
	print(x1 + r1 / 2, y1, r1 / 2)
else:
	(xd, yd) = (x1 - x2, y1 - y2)
	dist = float(xd ** 2 + yd ** 2) ** 0.5
	if dist > r1:
		print(x1, y1, r1)
	else:
		new_dist = (r1 - dist) / 2
		print(xd / dist * new_dist + x1, yd / dist * new_dist + y1, r1 - new_dist - 1e-09)


(R, x1, y1, x2, y2) = [float(x) for x in input().split()]
import math
eq = pow(x2 - x1, 2) + pow(y2 - y1, 2) - R * R
if eq < 0:
	rad = math.sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2)) + R
	rad /= 2
	if x2 != x1:
		tant = (y2 - y1) / (x2 - x1)
		ang = math.atan(tant)
	else:
		ang = math.radians(90)
	a = x1 - R * math.cos(ang)
	b = y1 - R * math.sin(ang)
	c = x1 + R * math.cos(ang)
	d = y1 + R * math.sin(ang)
	val1 = math.sqrt(pow(a - x2, 2) + pow(b - y2, 2))
	val2 = math.sqrt(pow(c - x2, 2) + pow(d - y2, 2))
	if val1 < val2:
		print((c + x2) / 2, (d + y2) / 2, rad)
	else:
		print((a + x2) / 2, (b + y2) / 2, rad)
else:
	print(x1, y1, R)


from math import sqrt
(R, x1, y1, x2, y2) = map(eval, input().split())
if x1 == x2 and y1 == y2:
	res = (x1 + R / 2, y1, R / 2)
elif (x1 - x2) ** 2 + (y1 - y2) ** 2 >= R ** 2:
	res = (x1, y1, R)
else:
	d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	r = (d + R) / 2
	x = x2 + r * (x1 - x2) / d
	y = y2 + r * (y1 - y2) / d
	res = (x, y, r)
print('{} {} {}'.format(*res))


eps = 1e-14
(R, x1, y1, x2, y2) = map(int, input().split())
rst = ((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) ** (1 / 2)
if rst > R:
	print(x1, y1, R - eps)
else:
	of = rst
	r = (R + of) / 2
	dx = x1 - x2
	dy = y1 - y2
	if of != 0:
		dx1 = (1 / 2 + R / (2 * of)) * dx
		dy1 = (1 / 2 + R / (2 * of)) * dy
	else:
		dx1 = R / 2
		dy1 = 0
	x = x2 + dx1
	y = y2 + dy1
	print(x, y, r - eps)


(R, x1, y1, x2, y2) = map(int, input().split())
if x1 == x2 and y1 == y2:
	print(x1, 1 / 2 * R + y1, R / 2)
elif x1 == x2:
	if y2 >= y1 + R or y2 < y1 - R:
		print(x1, y1, R)
	elif y1 < y2 < y1 + R:
		Rad = 2 * R - y1 - R + y2
		y_res = y1 - R + Rad / 2
		print(x1, y_res, Rad / 2)
	else:
		Rad = 2 * R - (y2 - y1 + R)
		y_res = y1 + R - Rad / 2
		print(x1, y_res, Rad / 2)
else:
	k = (y1 - y2) / (x1 - x2)
	b = (y2 * x1 - y1 * x2) / (x1 - x2)
	D = (k * (b - y1) - x1) ** 2 - (1 + k ** 2) * (x1 ** 2 + (b - y1) ** 2 - R ** 2)
	x_1 = (-(k * (b - y1) - x1) + D ** 0.5) / (1 + k ** 2)
	x_2 = (-(k * (b - y1) - x1) - D ** 0.5) / (1 + k ** 2)
	y_1 = k * x_1 + b
	y_2 = k * x_2 + b
	if (x2 - x_1) ** 2 + (y_1 - y2) ** 2 > (x2 - x_2) ** 2 + (y_2 - y2) ** 2:
		Rad = ((x2 - x_1) ** 2 + (y_1 - y2) ** 2) ** 0.5
		res_x = x2 * 1.0 + (x_1 - x2) / 2
		res_y = y2 * 1.0 + (y_1 - y2) / 2
	else:
		Rad = ((x2 - x_2) ** 2 + (y_2 - y2) ** 2) ** 0.5
		res_x = x2 * 1.0 + (x_2 - x2) / 2
		res_y = y2 * 1.0 + (y_2 - y2) / 2
	if Rad >= 2 * R:
		print(x1, y1, R)
	else:
		print(res_x, res_y, Rad / 2)


from math import *

def dist(x1, y1, x2, y2):
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
inp_arr = input().split()
R = float(inp_arr[0])
x1 = float(inp_arr[1])
y1 = float(inp_arr[2])
x2 = float(inp_arr[3])
y2 = float(inp_arr[4])
if dist(x1, y1, x2, y2) >= R:
	print(x1, y1, R)
else:
	if x1 == x2:
		theta = pi / 2
	else:
		m = (y2 - y1) / (x2 - x1)
		theta = atan(m)
	ep = []
	ep.append((x1 + R * cos(theta), y1 + R * sin(theta)))
	ep.append((x1 - R * cos(theta), y1 - R * sin(theta)))
	i = 0
	if dist(x2, y2, ep[0][0], ep[0][1]) >= R:
		i = 0
	else:
		i = 1
	r = dist(x2, y2, ep[i][0], ep[i][1]) / 2
	x = (x2 + ep[i][0]) / 2
	y = (y2 + ep[i][1]) / 2
	print(x, y, r)


import sys, math
f = sys.stdin
(R, x1, y1, x2, y2) = map(int, f.readline().split())
dx = x1 - x2
dy = y1 - y2
if dx ** 2 + dy ** 2 >= R ** 2:
	print(x1, y1, R)
elif dx == 0 and dy == 0:
	print(x1 + R / 2, y1, R / 2)
else:
	dl = (dx ** 2 + dy ** 2) ** 0.5
	r = (dl + R) / 2
	ax = x2 + dx / dl * r
	ay = y2 + dy / dl * r
	print(ax, ay, r)


(R, a, b, c, d) = map(int, input().split())
da = ((a - c) ** 2 + (b - d) ** 2) ** 0.5
if da >= R:
	print(a, b, R)
elif da == 0:
	print(a, b + R / 2, R / 2)
else:
	(x, y) = (a - R * (c - a) / da, b - R * (d - b) / da)
	print((x + c) / 2, (y + d) / 2, (da + R) / 2)


import math

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

def t(x, y, cx, cy, k):
	return ((x - cx) * k + cx, (y - cy) * k + cy)
(r, x1, y1, x2, y2) = map(int, input().split(' '))
d = dist(x1, y1, x2, y2)
if d > r:
	print(x1, y1, r)
else:
	newd = (r + d) / 2 - d
	if x1 == x2:
		ax = x1
		if y2 > y1:
			ay = y1 - newd
		else:
			ay = y1 + newd
		print(x1, ay, dist(ax, ay, x2, y2))
	else:
		k = -newd / d
		(ax, ay) = t(x2, y2, x1, y1, k)
		print(ax, ay, dist(ax, ay, x2, y2))


import math
from math import sin, cos
from decimal import Decimal
(R, x1, y1, x2, y2) = map(int, input().split())
if ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 >= R:
	print(x1, y1, R)
	exit(0)
r = (((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 + R) / 2
if x1 == x2 and y1 == y2:
	print((2 * x1 + R) / 2, y1, R / 2)
	exit(0)
s = abs((y2 - y1) / ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5)
c = abs((x2 - x1) / ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5)
if x2 <= x1 and y2 <= y1:
	x = (x1 + R * c + x2) / 2.0
	y = (y1 + R * s + y2) / 2.0
elif x2 >= x1 and y2 >= y1:
	x = (x1 - R * c + x2) / 2.0
	y = (y1 - R * s + y2) / 2.0
elif x2 <= x1 and y2 >= y1:
	x = (x1 + R * c + x2) / 2.0
	y = (y1 - R * s + y2) / 2.0
elif x2 >= x1 and y2 <= y1:
	x = (x1 - R * c + x2) / 2.0
	y = (y1 + R * s + y2) / 2.0
print(Decimal(x), Decimal(y), Decimal(r))


def main():
	(R, x1, y1, x2, y2) = map(int, input().split())
	if (x1 - x2) ** 2 + (y1 - y2) ** 2 >= R ** 2:
		return (x1, y1, R)
	if x1 == x2 and y1 == y2:
		return (x1 + 0.5 * R, y1, 0.5 * R)
	vx = x1 - x2
	vy = y1 - y2
	vnorm = (vx ** 2 + vy ** 2) ** 0.5
	r = R / vnorm
	return (0.5 * (x1 + x2 + vx * r), 0.5 * (y1 + y2 + vy * r), 0.5 * (R + vnorm))
(x, y, R) = main()
print(x, y, R)


from math import sqrt
dist = lambda x, y, a, b: sqrt((x - a) * (x - a) + (y - b) * (y - b))
(R, x1, y1, x2, y2) = map(float, input().split())
fafa_dist = dist(x1, y1, x2, y2)
if fafa_dist >= R:
	ans = (x1, y1, R)
elif fafa_dist == 0:
	ans = (x1, y1 + R / 2, R / 2)
else:
	ans = (x2 + (x1 - x2) / fafa_dist * (R + fafa_dist) / 2, y2 + (y1 - y2) / fafa_dist * (R + fafa_dist) / 2, (R + fafa_dist) / 2)
print('%.12f %.12f %.12f\n' % ans)


def solve(r, x2a, y2a):
	b = r / (1 + abs(y2a / x2a) ** 2) ** 0.5
	h = r / (1 + abs(x2a / y2a) ** 2) ** 0.5
	xa = (abs(x2a) - b) / 2
	ya = (abs(y2a) - h) / 2
	if x2a < 0 and y2a < 0:
		return [xa * -1, ya * -1]
	elif x2a < 0 and y2a > 0:
		return [xa * -1, ya]
	elif x2a > 0 and y2a > 0:
		return [xa, ya]
	else:
		return [xa, ya * -1]

def check(x1, x2, y1, y2, r):
	if ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 > r:
		print(x1, y1, r)
		return True
	elif x1 == x2 and y1 == y2:
		print((x1 + (x1 + r / 2 ** 0.5)) / 2, (y1 + (y1 + r / 2 ** 0.5)) / 2, r / 2)
		return True
	elif x1 == x2 and y1 != y2:
		if y1 - y2 < 0:
			r1 = abs((y1 - r + y2) / 2 - (y1 - r))
			print(float(x1), (y1 - r + y2) / 2, r1)
			return True
		else:
			r1 = abs((y1 + r + y2) / 2 - (y1 + r))
			print(float(x1), (y1 + r + y2) / 2, r1)
			return True
	elif y1 == y2 and x1 != x2:
		if x1 - x2 < 0:
			r1 = abs((x1 - r + x2) / 2 - (x1 - r))
			print((x1 - r + x2) / 2, float(y1), r1)
			return True
		else:
			r1 = abs((x1 + r + x2) / 2 - (x1 + r))
			print((x1 + r + x2) / 2, float(y1), r1)
			return True
	else:
		return False
(r, x1, y1, x2, y2) = map(int, input().split(' '))
if check(x1, x2, y1, y2, r) == False:
	t = solve(r, x2 - x1, y2 - y1)
	xa = t[0] + x1
	ya = t[1] + y1
	r1 = ((xa - x2) ** 2 + (ya - y2) ** 2) ** 0.5
	print(xa, ya, r1)


(R, x, y, u, v) = map(int, input().split())
d = ((u - x) ** 2 + (v - y) ** 2) ** 0.5
r = (R + d) / 2
if d > R:
	print(x, y, R)
elif d:
	k = r / d - 1
	print(x + (x - u) * k, y + (y - v) * k, r)
else:
	print(x, y + r, r)


(r, x1, y1, x2, y2) = map(int, input().split())
s = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
s2 = s
if s >= r:
	print(x1, y1, r)
else:
	s += r
	r2 = s / 2
	if s2 == 0:
		print((2 * x1 + r) / 2, y1, r2)
	else:
		ans1 = ((y1 - y2) * s / s2 + 2 * y2) / 2
		ans2 = ((x1 - x2) * s / s2 + 2 * x2) / 2
		print(ans2, ans1, r2)


import sys, math
f = sys.stdin
(r, x, y, x1, y1) = list(map(int, f.readline().split()))
dx = x - x1
dy = y - y1
if dx ** 2 + dy ** 2 >= r ** 2:
	print(x, y, r)
elif dx == 0 and dy == 0:
	print(x + r / 2, y1, r / 2)
else:
	dl = (dx ** 2 + dy ** 2) ** 0.5
	r = (dl + r) / 2
	x = x1 + dx / dl * r
	y = y1 + dy / dl * r
	print(x, y, r)


(r, x1, y1, x2, y2) = map(int, input().split())
w = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
if w > r:
	print(x1, y1, r)
elif not w:
	print(x1 - r / 2, y1, r / 2)
else:
	print(x1 - (x2 - x1) * ((w + r) / 2 / w - 1), y1 - (y2 - y1) * ((w + r) / 2 / w - 1), (w + r) / 2)


(r, x1, y1, x2, y2) = map(int, input().split())
dis = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if dis >= r:
	print(x1, y1, r)
else:
	if dis == 0:
		x3 = x1 + r
		y3 = y1
	else:
		x3 = x1 + (x1 - x2) * r / dis
		y3 = y1 + (y1 - y2) * r / dis
	x4 = (x2 + x3) / 2
	y4 = (y2 + y3) / 2
	print(x4, y4, (r + dis) / 2)


(r, x1, y1, x2, y2) = map(int, input().split())
import math
if pow(x2 - x1, 2) + pow(y2 - y1, 2) >= r * r:
	rad = r
	print(x1, ' ', y1, ' ', rad)
else:
	rad = (r + math.sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) / 2
	dist = math.sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))
	m = rad - dist
	if dist != 0:
		x = ((m + dist) * x1 - m * x2) / dist
		y = ((m + dist) * y1 - m * y2) / dist
	else:
		x = x1 + r / 2
		y = y1
		rad = 0.5 * r
	print(x, ' ', y, ' ', rad)


from math import sqrt
(r, x1, y1, x2, y2) = [int(i) for i in input().split()]
if (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) >= r * r:
	print(x1, y1, r)
elif x1 == x2 and y1 == y2:
	print(x1, y1 + r / 2.0, r / 2.0)
else:
	ans_r = (sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) + r) / 2.0
	if x1 == x2:
		if y1 > y2:
			print(x1, y2 + ans_r, ans_r)
		else:
			print(x1, y2 - ans_r, ans_r)
	else:
		tan = (y1 - y2) / (x1 - x2)
		if tan == 0:
			if x1 > x2:
				print(x2 + ans_r, y1, ans_r)
			else:
				print(x2 - ans_r, y1, ans_r)
		elif tan > 0:
			if x1 > x2:
				cos = 1 / sqrt(1 + tan * tan)
				sin = sqrt(1 - cos * cos)
				print(x2 + ans_r * cos, y2 + ans_r * sin, ans_r)
			else:
				cos = -1 / sqrt(1 + tan * tan)
				sin = -sqrt(1 - cos * cos)
				print(x2 + ans_r * cos, y2 + ans_r * sin, ans_r)
		elif x1 > x2:
			cos = 1 / sqrt(1 + tan * tan)
			sin = -sqrt(1 - cos * cos)
			print(x2 + ans_r * cos, y2 + ans_r * sin, ans_r)
		else:
			cos = -1 / sqrt(1 + tan * tan)
			sin = sqrt(1 - cos * cos)
			print(x2 + ans_r * cos, y2 + ans_r * sin, ans_r)


(r, x, y, fx, fy) = map(int, input().split())
d = ((fy - y) ** 2 + (fx - x) ** 2) ** (1 / 2)
if d == 0:
	rcen = r / 2
	xans = x + rcen
	yans = y + rcen
	print(str(float(xans)) + ' ' + str(float(y)) + ' ' + str(float(rcen)))
elif d > r:
	print(str(float(x)) + ' ' + str(float(y)) + ' ' + str(float(r)))
else:
	rcen = (d + r) / 2
	xcen = (x - fx) * rcen / d
	ycen = (y - fy) * rcen / d
	xans = xcen + fx
	yans = ycen + fy
	print(str(float(xans)) + ' ' + str(float(yans)) + ' ' + str(float(rcen)))


import math
(r, x1, y1, x2, y2) = input().split()
r = int(r)
x1 = int(x1)
y1 = int(y1)
x2 = int(x2)
y2 = int(y2)
s = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
rad = (s + r) / 2
if s > 0:
	si = (y2 - y1) / s
	co = (x2 - x1) / s
	x0 = x2 - (r + s) * co
	y0 = y2 - (r + s) * si
	ans1 = (x0 + x2) / 2
	ans2 = (y0 + y2) / 2
	if s > r:
		rad = r
		ans1 = x1
		ans2 = y1
if s == 0:
	ans1 = x1 - r / 2
	ans2 = y1
	rad = r / 2
print(ans1, ' ', ans2, ' ', rad)


(R, x1, y1, x2, y2) = map(int, input().split())
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if d == 0:
	print(x1 + R / 2, y1, R / 2 - 10 ** (-9))
	exit()
if R < d:
	print(x1, y1, R)
else:
	s = ((d + R) * x1 - R * x2) / d
	t = ((d + R) * y1 - R * y2) / d
	x_ap = (s + x2) / 2
	y_ap = (t + y2) / 2
	r = ((x_ap - x2) ** 2 + (y_ap - y2) ** 2) ** 0.5 - 10 ** (-9)
	print(x_ap, y_ap, r)


import sys
from math import sqrt, atan2, cos, sin, degrees

def angle(x1, y1, x2, y2):
	xDiff = x2 - x1
	yDiff = y2 - y1
	return atan2(yDiff, xDiff)

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

def solution(R, x1, y1, x2, y2):
	if (x2 - x1) ** 2 + (y1 - y2) ** 2 <= R ** 2:
		if x2 < x1:
			theta = angle(x2, y2, x1, y1)
			x_circle = x1 + R * cos(theta)
			y_circle = y1 + R * sin(theta)
		else:
			theta = angle(x1, y1, x2, y2)
			x_circle = x1 - R * cos(theta)
			y_circle = y1 - R * sin(theta)
		xap = (x_circle + x2) / 2
		yap = (y_circle + y2) / 2
		r = dist(x2, y2, xap, yap)
		return (xap, yap, r)
	else:
		return (x1, y1, R)
(R, x1, y1, x2, y2) = list(map(int, sys.stdin.readline().strip().split(' ')))
print(' '.join([str(i) for i in solution(R, x1, y1, x2, y2)]))


(r, x0, y0, x, y) = map(int, input().split())
res = ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5
if res:
	v = r / res
	(vx, vy) = ((x - x0) * v, (y - y0) * v)
	(px, py) = (x0 - vx, y0 - vy)
	(ax, ay) = (x - (x - px) / 2, y - (y - py) / 2)
	ar = ((ax - x) ** 2 + (ay - y) ** 2) ** 0.5
	if abs(ar) <= r:
		print(ax, ay, ar)
	else:
		print(x0, y0, r)
else:
	print(x0 + r / 2, y0, r / 2)


(ap, x, y, x2, y2) = map(int, input().split(' '))
d = (abs(x - x2) ** 2 + abs(y - y2) ** 2) ** 0.5
if d == 0:
	r = ap / 2
	x3 = x
	y3 = (y + y + ap) / 2
elif d >= ap:
	r = ap
	x3 = x
	y3 = y
else:
	r = (ap + d) / 2
	vx = x - x2
	vy = y - y2
	vx /= d
	vy /= d
	vx *= r
	vy *= r
	x3 = vx + x2
	y3 = vy + y2
print(x3, y3, r)


import sys
(R, x, y, s, t) = list(map(int, input().split()))
if (s - x) ** 2 + (t - y) ** 2 > R * R:
	print(x, y, R)
	return
dx = x - s
dy = y - t
r = (dx ** 2 + dy ** 2) ** 0.5
if abs(r) < 1e-09:
	dx = 1
	dy = 0
else:
	dx /= r
	dy /= r
a = s + dx * (R + r) / 2
b = t + dy * (R + r) / 2
print(a, b, (R + r) / 2)


import math
(r, x1, y1, x2, y2) = input().strip().split(' ')
(r, x1, y1, x2, y2) = [int(r), int(x1), int(y1), int(x2), int(y2)]
a = (x2 - x1) ** 2
b = (y2 - y1) ** 2
d = math.sqrt(a + b)
if d == 0:
	print(float(x1 + r / 2), float(y1), r / 2)
elif d >= r:
	print(float(x1), float(y1), float(r))
else:
	x = ((d + r) * x1 - r * x2) / d
	y = ((d + r) * y1 - r * y2) / d
	k = (d + r) / 2
	u = (x + x2) / 2
	v = (y + y2) / 2
	print(u, v, k)


from fractions import gcd
from heapq import *
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7

def main():
	(r, x1, y1, x2, y2) = map(int, input().split())
	d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	if x1 == x2 and y1 == y2:
		R = r / 2
		X = x1 + r / 2
		Y = y1
	elif d > r:
		R = r
		X = x1
		Y = y1
	else:
		R = (r + d) / 2
		X = R / d * (x1 - x2) + x2
		Y = R / d * (y1 - y2) + y2
	print(X, Y, R)
main()


from math import *
from decimal import *

def dis(x, y):
	return sqrt(x * x + y * y)

def mul(x, y, m):
	return (m * x, m * y)
(R, x1, y1, x2, y2) = map(Decimal, input().split())
r = Decimal(dis(x1 - x2, y1 - y2))
ans = (r + R) / Decimal(2)
if r > R:
	print(x1, y1, R)
elif r == 0:
	print(x1 + ans, y1, ans)
else:
	(ax, ay) = mul(x1 - x2, y1 - y2, ans / r)
	print(x2 + ax, y2 + ay, ans)


import math
(R, x1, y1, x2, y2) = map(int, input().split())
dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
x1 = x1 / 1
y1 = y1 / 1
R = R / 1
if dist >= R:
	print(x1, y1, R)
else:
	if x1 == x2:
		xA = x1
		yA1 = R + y1
		yA2 = y1 - R
		dist1 = abs(yA1 - y2)
		dist2 = abs(y2 - yA2)
		if dist1 > dist2:
			yA = yA1
			rA = dist1
		else:
			yA = yA2
			rA = dist2
	else:
		m = (y2 - y1) / (x2 - x1)
		p = x1
		q = y1
		c = y1 - m * x1
		B = 2 * (m * c - m * q - p)
		A = m ** 2 + 1
		C = q ** 2 - R ** 2 + p ** 2 - 2 * c * q + c ** 2
		delta = B ** 2 - 4 * A * C
		xA1 = (-B + math.sqrt(abs(delta))) / (2 * A)
		xA2 = (-B - math.sqrt(abs(delta))) / (2 * A)
		yA1 = m * xA1 + c
		yA2 = m * xA2 + c
		dist1 = math.sqrt((xA1 - x2) ** 2 + (yA1 - y2) ** 2)
		dist2 = math.sqrt((xA2 - x2) ** 2 + (yA2 - y2) ** 2)
		if dist1 > dist2:
			xA = xA1
			yA = yA1
		else:
			xA = xA2
			yA = yA2
		rA = math.sqrt((xA - x2) ** 2 + (yA - y2) ** 2)
	print((xA + x2) / 2, (yA + y2) / 2, rA / 2)


(r, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r * r:
	print(x1, y1, r)
	exit()
if x1 == x2:
	if y2 < y1:
		print(x1, y2 + (y1 + r - y2) / 2, (y1 + r - y2) / 2)
	else:
		print(x1, y2 - (y2 - y1 + r) / 2, (y2 - y1 + r) / 2)
else:
	k = (y2 - y1) / (x2 - x1)
	b = y1 - k * x1
	B = b + 0
	a = k * k + 1
	c = x1 * x1 + b * b - 2 * b * y1 + y1 * y1 - r * r
	b = 2 * k * b - 2 * x1 - 2 * k * y1
	d = b * b - 4 * a * c
	X1 = (-b + d ** 0.5) / (2 * a)
	X2 = (-b - d ** 0.5) / (2 * a)
	Y1 = k * X1 + B
	Y2 = k * X2 + B
	r1 = ((X1 - x2) ** 2 + (Y1 - y2) ** 2) ** 0.5
	r2 = ((X2 - x2) ** 2 + (Y2 - y2) ** 2) ** 0.5
	if r1 > r2:
		print((x2 + X1) / 2, (y2 + Y1) / 2, r1 / 2)
	else:
		print((x2 + X2) / 2, (y2 + Y2) / 2, r2 / 2)


from math import *

def aaa():
	(r, x1, y1, x2, y2) = map(int, input().split())
	rz = r * r
	dz = (x2 - x1) ** 2 + (y2 - y1) ** 2
	if dz >= rz:
		return (x1, y1, r)
	dia = r + sqrt(dz)
	rr = dia / 2
	rad = atan2(y1 - y2, x1 - x2)
	yy = sin(rad) * rr + y2
	xx = cos(rad) * rr + x2
	return (xx, yy, rr)
print(*aaa())


(r, x1, y1, x2, y2) = map(int, input().split())
from math import sqrt

def distance(x1, y1, x2, y2):
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if distance(x1, y1, x2, y2) >= r:
	print(x1, y1, r)
elif x1 == x2 and y1 == y2:
	print((x1 + x1 - r) / 2, y1, r / 2)
else:
	a = y2 - y1
	b = x1 - x2
	if b != 0:
		c = x1 * (y1 - y2) + y1 * (x2 - x1)
		x3 = x1 + r / sqrt(1 + a ** 2 / b ** 2)
		x4 = x1 - r / sqrt(1 + a ** 2 / b ** 2)
		y3 = y1 + r * abs(a / b) / sqrt(1 + a ** 2 / b ** 2)
		y4 = y1 - r * abs(a / b) / sqrt(1 + a ** 2 / b ** 2)
		q = [x3, x4]
		w = [y3, y4]
		for i in range(2):
			for j in range(2):
				if round(distance(x2, y2, q[i], w[j]), 6) == round(distance(x1, y1, x2, y2) + r, 6):
					xi = q[i]
					yi = w[j]
					break
		xres = (xi + x2) / 2
		yres = (yi + y2) / 2
		radius = distance(xres, yres, xi, yi)
		print(xres, yres, radius)
	else:
		q = [x1, x1]
		w = [y1 + r, y1 - r]
		for i in range(2):
			for j in range(2):
				if distance(x2, y2, q[i], w[j]) == distance(x1, y1, x2, y2) + r:
					xi = q[i]
					yi = w[j]
					break
		xres = (xi + x2) / 2
		yres = (yi + y2) / 2
		radius = distance(xres, yres, xi, yi)
		print(xres, yres, radius)


import math
(R, x1, y1, x2, y2) = map(float, input().strip().split(' '))
d = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if x1 == x2 and y1 == y2:
	print(x1 + R / 2, y1, R / 2, sep=' ')
elif d >= R:
	print(x1, y1, R, sep=' ')
elif d < R:
	x = ((d + R) * x1 - R * x2) / d
	y = ((d + R) * y1 - R * y2) / d
	x = (x + x2) / 2
	y = (y + y2) / 2
	r = (d + R) / 2
	print(x, y, r, sep=' ')


(r, x1, y1, x2, y2) = map(int, input().split())
if (x1 - x2) ** 2 + (y1 - y2) ** 2 > r * r:
	print(x1, y1, r)
	exit()
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
r2 = (r + d) / 2
if d == 0:
	x3 = x2 + r / 2
	y3 = y2
else:
	x3 = x2 + (x1 - x2) / d * r2
	y3 = y2 + (y1 - y2) / d * r2
print(x3, y3, r2)


import math
(R, x1, y1, x2, y2) = map(int, input().split())
d2 = (x2 - x1) ** 2 + (y2 - y1) ** 2
if d2 >= R ** 2:
	(xap, yap, rap) = (x1, y1, R)
elif d2 == 0:
	rap = 0.5 * R
	(xap, yap) = (x1 + rap, y1)
else:
	dist = math.sqrt(d2)
	rap = 0.5 * (dist + R)
	k = rap / dist
	(xap, yap) = (x2 + k * (x1 - x2), y2 + k * (y1 - y2))
print(xap, yap, rap)


import math
data = input().split(' ', 5)
diameter = float(data[0])
apx = float(data[1])
apy = float(data[2])
ntbx = float(data[3])
ntby = float(data[4])
distancex = abs(apx - ntbx)
distancey = abs(apy - ntby)
distance = math.sqrt(math.pow(distancex, 2) + math.pow(distancey, 2))
if distance == 0:
	print(str(float(apx)) + ' ' + str(float(apy - float(diameter / 2))) + ' ' + str(float(diameter / 2)))
elif distance > diameter:
	print(str(float(apx)) + ' ' + str(float(apy)) + ' ' + str(float(diameter)))
else:
	distanceacp = float(distance + diameter) / 2
	k = distanceacp / distance
	if ntbx < apx:
		acpx = ntbx + distancex * k
	else:
		acpx = ntbx - distancex * k
	if ntby < apy:
		acpy = ntby + distancey * k
	else:
		acpy = ntby - distancey * k
	print(str(acpx) + ' ' + str(acpy) + ' ' + str(distanceacp))


def read():
	return [float(x) for x in input().split()]

def dist(p1x, p1y, p2x, p2y):
	return ((p1x - p2x) * (p1x - p2x) + (p1y - p2y) * (p1y - p2y)) ** 0.5

def main():
	(R, x1, y1, x2, y2) = read()
	d = dist(x1, y1, x2, y2)
	if d > R:
		print(x1, y1, R)
		return
	if d == 0:
		print(x1 + R / 2, y1, R / 2)
		return
	r = (R + d) / 2
	l = (R + d) / d / 2
	p1x = x2 + (x1 - x2) * l
	p1y = y2 + (y1 - y2) * l
	print(p1x, p1y, r)
main()


from math import sqrt

def sq(x):
	return x ** 2

def dist(a, b, p, q):
	return sqrt(sq(a - p) + sq(b - q))

def solvequad(a, b, c):
	d = sqrt(sq(b) - 4 * a * c)
	return ((-b + d) / (2 * a), (-b - d) / (2 * a))
(r, x1, y1, fx, fy) = map(int, input().split())
if sqrt(sq(x1 - fx) + sq(y1 - fy)) > r + 5e-07:
	print(x1, y1, r)
elif fx == x1:
	rc = max(abs(fy - (y1 + r)), abs(fy - (y1 - r))) / 2
	if fy > y1:
		yc = fy - rc
	else:
		yc = fy + rc
	print(x1, yc, rc)
else:
	l = dist(x1, y1, fx, fy)
	x = x1 + (x1 - fx) / l * r
	y = y1 + (y1 - fy) / l * r
	xc = (x + fx) / 2
	yc = (y + fy) / 2
	rc = dist(x, y, fx, fy) / 2
	print(xc, yc, rc)


from math import sqrt
str = input().split()
R = int(str[0])
x1 = int(str[1])
y1 = int(str[2])
x2 = int(str[3])
y2 = int(str[4])
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R ** 2:
	x3 = float(x1)
	y3 = float(y1)
	r = float(R)
else:
	d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	if d != 0:
		r = (d + R) / 2
		a = r - d
		cos = abs(y2 - y1) / d
		sin = abs(x2 - x1) / d
		if x2 > x1:
			x3 = x1 - a * sin
		else:
			x3 = x1 + a * sin
		if y2 > y1:
			y3 = y1 - a * cos
		else:
			y3 = y1 + a * cos
	else:
		r = R / 2
		x3 = x1 + r
		y3 = float(y1)
print(x3, y3, r, sep=' ', end=' ')


(R, x1, y1, x2, y2) = map(int, input().split())
import math
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R ** 2:
	print(x1, y1, R)
else:
	if x1 == x2:
		if y2 <= y1:
			x = x1
			y = (y2 + y1 + R) / 2
			r = y - y2
		else:
			x = x1
			y = (y2 + y1 - R) / 2
			r = y2 - y
	else:
		a = (y1 - y2) / (x1 - x2)
		d = R / math.sqrt(1 + a ** 2)
		if x2 <= x1:
			xd = x1 + d
			yd = a * (xd - x1) + y1
			x = (x2 + xd) / 2
			y = (y2 + yd) / 2
			r = math.hypot(xd - x, yd - y)
		else:
			xd = x1 - d
			yd = a * (xd - x1) + y1
			x = (x2 + xd) / 2
			y = (y2 + yd) / 2
			r = math.hypot(xd - x, yd - y)
	print(x, y, r)


(r, x, y, u, v) = map(int, input().split())
(g, h) = (x - u, y - v)
d = (g * g + h * h) ** 0.5
if d < r:
	r = (r + d) / 2
	if d:
		k = r / d - 1
		x += g * k
		y += h * k
	else:
		y += r
print(x, y, r)


import math
(R, k1, k2, p1, p2) = tuple(map(float, input().split()))

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

def sol(R, k1, k2, p1, p2):
	kp = dist(k1, k2, p1, p2)
	if kp > R:
		return (k1, k2, R)
	r = (kp + R) / 2
	if kp != 0:
		napravl = (p1 - k1, p2 - k2)
		m = (p1 - napravl[0] * r / kp, p2 - napravl[1] * r / kp)
	else:
		kk = math.sqrt(2) / 2
		m = (k1 + kk * r, k2 + kk * r)
	return (m[0], m[1], r)
print(' '.join(list(map(str, sol(R, k1, k2, p1, p2)))))


(R, x1, y1, x2, y2) = map(int, input().split())
from math import sqrt

def dist(p1, p2):
	return sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2)
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R ** 2:
	print(x1, y1, R)
elif x2 - x1 == 0:
	xp = x1
	yp1 = y1 + sqrt(R ** 2 - (xp - x1) ** 2)
	yp2 = y1 - sqrt(R ** 2 - (xp - x1) ** 2)
	if dist((xp, yp1), (x2, y2)) > dist((xp, yp2), (x2, y2)):
		mid = ((x2 + xp) / 2, (y2 + yp1) / 2)
		r = dist((xp, yp1), (x2, y2)) / 2
		print(mid[0], mid[1], r)
	else:
		mid = ((x2 + xp) / 2, (y2 + yp2) / 2)
		r = dist((xp, yp2), (x2, y2)) / 2
		print(mid[0], mid[1], r)
else:
	m = (y2 - y1) / (x2 - x1)
	xp1 = x1 + sqrt(R ** 2 / (1 + m ** 2))
	xp2 = x1 - sqrt(R ** 2 / (1 + m ** 2))
	yp11 = y1 + sqrt(R ** 2 - (xp1 - x1) ** 2)
	yp12 = y1 - sqrt(R ** 2 - (xp1 - x1) ** 2)
	yp21 = y1 + sqrt(R ** 2 - (xp2 - x1) ** 2)
	yp22 = y1 - sqrt(R ** 2 - (xp2 - x1) ** 2)
	cands = [(xp1, yp11), (xp1, yp12), (xp2, yp21), (xp2, yp22)]
	imax = 0
	ma = 0
	for (i, e) in enumerate(cands):
		if dist((x2, y2), e) > ma:
			ma = dist((x2, y2), e)
			imax = i
	mid = ((x2 + cands[imax][0]) / 2, (y2 + cands[imax][1]) / 2)
	r = ma / 2
	print(mid[0], mid[1], r)


from math import *
(R, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R ** 2:
	print(float(x1), float(y1), float(R))
elif x1 == x2 and y1 == y2:
	print('%.15f' % float(x1 + R / 2), '%.15f' % float(y1), '%.15f' % (R / 2))
else:
	k = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	ansx = (x2 - x1) * -1 * (R - k) / k / 2 + x1
	ansy = (y2 - y1) * -1 * (R - k) / k / 2 + y1
	print('%.15f' % ansx, '%.15f' % ansy, '%.15f' % ((R + k) / 2))


from math import sqrt
(r, cx, cy, px, py) = map(int, input().split())

def findx(a, b, c):
	return ((-b + sqrt(b * b - 4 * a * c)) / (2 * a), (-b - sqrt(b * b - 4 * a * c)) / (2 * a))

def findy(x1, x2, m, c):
	return (m * x1 + c, m * x2 + c)

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

def ma1(cy, py, r):
	if abs(cy + r - py) > abs(cy - r - py):
		return (cx, cy + r)
	return (cx, cy - r)

def ma2(px, x1, py, y1, x2, y2):
	if dist(px, x1, py, y1) > dist(px, x2, py, y2):
		return (x1, y1)
	return (x2, y2)
if dist(cx, px, cy, py) > r:
	print(cx, cy, r)
elif px == cx:
	(ansx, ansy) = ma1(cy, py, r)
	print((px + ansx) / 2, (py + ansy) / 2, max(abs(cy + r - py), abs(cy - r - py)) / 2)
else:
	m = (py - cy) / (px - cx)
	c1 = py - (cy - py) / (cx - px) * px
	a = 1 + m * m
	b = -2 * cx + 2 * m * c1 - 2 * m * cy
	c = cx * cx + c1 * c1 + cy * cy - 2 * c1 * cy - r * r
	(x1, x2) = findx(a, b, c)
	(y1, y2) = findy(x1, x2, m, c1)
	(ansx, ansy) = ma2(px, x1, py, y1, x2, y2)
	print((px + ansx) / 2, (py + ansy) / 2, max(dist(px, x1, py, y1), dist(px, x2, py, y2)) / 2)


import math
(R, x1, y1, x2, y2) = map(int, input().split())
r = R
dist = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if dist >= R:
	print(x1, y1, R)
elif x1 == x2 and y1 == y2:
	print(x1 + R / 2, y1, R / 2)
else:
	x = (x1 * (dist + r) - x2 * r) / dist
	y = (y1 * (dist + r) - y2 * r) / dist
	dist = math.sqrt((x2 - x) ** 2 + (y2 - y) ** 2)
	print((x + x2) / 2, (y + y2) / 2, dist / 2)


import sys
import math
(R, x1, y1, x2, y2) = [int(num) for num in input().split(' ')]
if (x2 - x1) ** 2 + (y2 - y1) ** 2 > R ** 2:
	print(x1, y1, R)
	sys.exit()
if x1 == x2 and y2 == y1:
	print(x1 + R / 2, y1, R / 2)
	sys.exit()
else:
	if x1 == x2:
		rad1 = (abs(y1 - y2) + R) / 2
		if y2 < y1:
			x11 = x2
			y11 = (y2 + (y1 + R)) / 2
		else:
			x11 = x2
			y11 = (y2 + (y1 - R)) / 2
		print(x11, y11, rad1)
		sys.exit()
	p = (y1 - y2) * 1.0 / (x1 - x2)
	q = -p * x1 + y1
	s = q - y1
	t = (-2 * p * s * x1 - s * s + R * R - x1 * x1 * p * p + p * p * R * R) ** (1 / 2)
	x11 = (2 * x1 - 2 * p * s + 2 * t) / (2 * (1 + p * p))
	y11 = p * x11 + q
	x12 = (2 * x1 - 2 * p * s - 2 * t) / (2 * (1 + p * p))
	y12 = p * x12 + q
	rad1 = ((y2 - y11) * (y2 - y11) + (x2 - x11) * (x2 - x11)) ** (1 / 2) / 2
	rad2 = ((y2 - y12) * (y2 - y12) + (x2 - x12) * (x2 - x12)) ** (1 / 2) / 2
	if rad1 > rad2:
		print((x11 + x2) / 2, (y11 + y2) / 2, rad1)
	else:
		print((x12 + x2) / 2, (y12 + y2) / 2, rad2)


(r, x1, y1, x2, y2) = map(int, input().split())
if x1 != x2:
	k = (y1 - y2) / (x1 - x2)
elif (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r ** 2:
	print(x1, y1, r)
	exit(0)
else:
	r1 = (r + abs(y2 - y1)) / 2
	if y2 + 2 * r1 == y1 + r:
		print(x1, r1 + y2, r1)
	else:
		print(x1, y2 - r1, r1)
	exit(0)
if (x2 - x1) ** 2 + (y2 - y1) ** 2 <= r ** 2:
	b = y1 - (y1 - y2) * x1 / (x1 - x2)
	disk = ((-2 * x1 - 2 * k * y1 + 2 * k * b) ** 2 - 4 * (k * k + 1) * (b * b + y1 * y1 - 2 * b * y1 - r ** 2 + x1 ** 2)) ** 0.5
	qx1 = (2 * x1 + 2 * k * y1 - 2 * k * b + disk) / (2 * (k * k + 1))
	qx2 = (2 * x1 + 2 * k * y1 - 2 * k * b - disk) / (2 * (k * k + 1))
	qy1 = k * qx1 + b
	qy2 = k * qx2 + b
	qo = max(((qx1 - x2) ** 2 + (qy1 - y2) ** 2) ** 0.5, ((qx2 - x2) ** 2 + (qy2 - y2) ** 2) ** 0.5)
	r1 = qo / 2
	if qo == ((qx1 - x2) ** 2 + (qy1 - y2) ** 2) ** 0.5:
		print((qx1 + x2) / 2, (qy1 + y2) / 2, r1)
	if qo == ((qx2 - x2) ** 2 + (qy2 - y2) ** 2) ** 0.5:
		print((qx2 + x2) / 2, (qy2 + y2) / 2, r1)
else:
	print(x1, y1, r)


import math
(R, x1, y1, x2, y2) = list(map(int, input().split()))
v = [x1 - x2, y1 - y2]
if v != [0, 0]:
	lv = math.hypot(v[0], v[1])
	if lv <= R:
		sf = (lv + R) / lv / 2
		vs = [v[0] * sf, v[1] * sf]
		r = math.hypot(vs[0] - x2, vs[1] - y2)
		print(x2 + vs[0], y2 + vs[1], (lv + R) / 2)
	else:
		print(x1, y1, R)
else:
	print(x1 + R / 2, y1, R / 2)


(R, x1, y1, x2, y2) = [float(x) for x in input().split()]
dist = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if dist >= R:
	print(x1, y1, R)
elif dist == 0:
	print(x1 + R / 2, y1, R / 2)
else:
	r = (R + dist) / 2
	x3 = x2 + (x1 - x2) * r / dist
	y3 = y2 + (y1 - y2) * r / dist
	print(x3, y3, r)


import math

class Vector:

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

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

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

	def __mul__(self, other):
		if str(type(other)) == "<class 'int'>" or str(type(other)) == "<class 'float'>":
			return Vector(self.x * other, self.y * other)
		else:
			return self.x * other.x + self.y * other.y

	def __truediv__(self, other):
		return Vector(self.x / other, self.y / other)

	def __xor__(self, other):
		return self.x * other.y - other.x * self.y

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

	def __str__(self):
		return str(self.x) + ' ' + str(self.y)

	def get_nor(self):
		l = self.get_length()
		if l == 0:
			l = 1
		return Vector(self.x / l, self.y / l)

	def rotate(self):
		return Vector(-self.x, -self.y)
(r, x, y, x1, y1) = map(float, input().split())
if (x - x1) ** 2 + (y - y1) ** 2 < r ** 2:
	if x1 == x and y1 == y:
		v1 = Vector(r, 0)
	else:
		v1 = Vector(x1 - x, y1 - y).get_nor() * r
	v2 = v1.rotate()
	xp1 = x + v1.x
	yp1 = y + v1.y
	xp2 = x + v2.x
	yp2 = y + v2.y
	if (xp1 - x1) ** 2 + (yp1 - y1) ** 2 < (xp2 - x1) ** 2 + (yp2 - y1) ** 2:
		xp1 = xp2
		yp1 = yp2
	v3 = Vector(xp1 - x1, yp1 - y1) / 2
	ax = x1 + v3.x
	ay = y1 + v3.y
	print(ax, ay, v3.get_length())
else:
	print(x, y, r)


(R, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 <= R ** 2:
	dist = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
	if dist:
		r = (R + dist) / 2
		x2 += (x1 - x2) * r / dist
		y2 += (y1 - y2) * r / dist
		print(x2, y2, r)
	else:
		print(x1 + R / 2, y1, R / 2)
else:
	print(x1, y1, R)


from collections import defaultdict
from math import sin, pi, sqrt
(R, x2, y2, x1, y1) = list(map(int, input().split(' ')))

def distance(p, q):
	return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2
if (x1 - x2) ** 2 + (y1 - y2) ** 2 > R ** 2:
	print('{} {} {}'.format(x2, y2, R))
else:
	if x1 == x2:
		potential1 = (x1, y2 + sqrt(R ** 2 - (x1 - x2) ** 2))
		potential2 = (x1, y2 - sqrt(R ** 2 - (x1 - x2) ** 2))
	else:
		a = (y2 - y1) / (x2 - x1)
		b = y1
		a_eq = 1 + a ** 2
		b_eq = 2 * a * (b - a * x1 - y2) - 2 * x2
		c_eq = -R ** 2 + x2 ** 2 + (a * x1 - b + y2) ** 2
		delta = b_eq ** 2 - 4 * a_eq * c_eq
		x = (-b_eq + sqrt(delta)) / (2 * a_eq)
		potential1 = (x, a * (x - x1) + b)
		x = (-b_eq - sqrt(delta)) / (2 * a_eq)
		potential2 = (x, a * (x - x1) + b)
	if distance((x1, y1), potential1) > distance((x1, y1), potential2):
		extreme = potential1
	else:
		extreme = potential2
	radius = sqrt(distance(extreme, (x1, y1))) / 2
	liste = [str((extreme[0] + x1) / 2), str((extreme[1] + y1) / 2), str(radius)]
	print(' '.join(liste))


from math import hypot
(r, x1, y1, x2, y2) = map(int, input().split())
if (x1 - x2) ** 2 + (y1 - y2) ** 2 >= r ** 2:
	print(x1, y1, r)
elif x1 == x2 and y1 == y2:
	print((2 * x1 + r) / 2, y1, r / 2)
else:
	of = hypot(x2 - x1, y2 - y1)
	rn = (r + of) / 2
	xn = -r / of * (x2 - x1) + x1
	yn = -r / of * (y2 - y1) + y1
	x = (xn + x2) / 2
	y = (yn + y2) / 2
	print(x, y, rn)


EPS = 1e-09

def sqdist(x1, y1, x2, y2):
	return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)
(R, x1, y1, x2, y2) = list(map(int, input().split()))
r2 = sqdist(x1, y1, x2, y2)
if r2 > R * R:
	print(x1, y1, R - EPS)
	exit()
if x1 == x2 and y1 == y2 or r2 == 0:
	print(x1 - R / 2 - EPS, y1, R / 2)
	exit()
maxr = (R + r2 ** 0.5 - EPS) / 2
smesh = (R - r2 ** 0.5) / 2
bestx = x1 + (x1 - x2) * smesh / r2 ** 0.5
besty = y1 + (y1 - y2) * smesh / r2 ** 0.5
print(bestx, besty, maxr)


class Point:

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

def vector_by_points(pt1, pt2):
	return Vector(pt2.x - pt1.x, pt2.y - pt1.y)

class Vector:

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

	def length(self):
		return (self.x ** 2 + self.y ** 2) ** 0.5

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

	def __mul__(self, other):
		return Vector(self.x * other, self.y * other)

	def normalise(self):
		l = self.length()
		if l != 0:
			return Vector(self.x / l, self.y / l)
		return self
(r, x1, y1, x2, y2) = map(int, input().split())
center = Point(x1, y1)
notebook = Point(x2, y2)
v = vector_by_points(notebook, center)
dst = v.length()
if dst - r <= 1e-06:
	ans = (2 * r - (r - dst)) / 2
	if dst == 0:
		print(x1 + r / 2, y1, ans)
	else:
		v = v.normalise() * ans + notebook
		print(v.x, v.y, ans)
else:
	print(x1, y1, r)


from decimal import Decimal
import math
(R, x1, y1, x2, y2) = [Decimal(x) for x in input().split()]
dis = Decimal.from_float(math.hypot(x1 - x2, y1 - y2))
if dis >= R:
	print(x1, y1, R)
elif x1 == x2 and y1 == y2:
	print(x1 + R / 2, y1, R / 2)
else:
	r = (R + dis) / 2
	x = x2 + r * (x1 - x2) / dis
	y = y2 + r * (y1 - y2) / dis
	print(x, y, r)


from math import sqrt
(R, x1, y1, x2, y2) = map(int, input().split())
d = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if d >= R:
	print(x1, y1, R)
else:
	r = (d + R) / 2
	if d == 0:
		(xa, ya) = (x1 + r, y1)
	else:
		k = (R - d) / (2 * d)
		(xa, ya) = (x1 + (x1 - x2) * k, y1 + (y1 - y2) * k)
	print(xa, ya, r)


import math

def inp():
	a = input().split()
	return list(map(int, a))

def C(R, x1, y1, x2, y2):
	dy = y2 - y1
	dx = x2 - x1
	l = math.sqrt(dx ** 2 + dy ** 2)
	if l == 0:
		print(x1, y1 + R / 2, R / 2)
		return 0
	if l > R:
		print(x1, y1, R)
		return 0
	r = (l + R) / 2
	c = R - r
	yp = dy / l * (l + c) - y2 + y1
	xp = (l + c) * dx / l - x2 + x1
	x = x1 - xp
	y = y1 - yp
	print(x, y, r)
C(*inp())


(r, x1, y1, x2, y2) = map(float, input().split())
d2 = (x2 - x1) ** 2 + (y2 - y1) ** 2
if d2 >= r * r:
	print(x1, y1, r)
	exit(0)
if x1 == x2 and y1 == y2:
	print(x1 + 0.5 * r, y1, 0.5 * r)
	exit(0)
d2 = d2 ** 0.5
c = (d2 + r) / (2 * d2)
print(x2 + (x1 - x2) * c, y2 + (y1 - y2) * c, (d2 + r) / 2)


(r, x1, y1, x2, y2) = map(int, input().split())
from math import sqrt
EPS = 1e-05
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r ** 2:
	print(x1, y1, r)
	exit()
if (x2 - x1) ** 2 + (y2 - y1) ** 2 < EPS:
	print(x1 + r / 2, y2, r / 2)
	exit()
dst = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
rb = (dst + r) / 2
k = rb / dst
one = x1 - x2
two = y1 - y2
x3 = one * k + x2
y3 = two * k + y2
print(x3, y3, rb)


from math import hypot, sqrt
(R, x1, y1, x2, y2) = list(map(int, input().split()))
if hypot(x1 - x2, y1 - y2) > R:
	print(x1, y1, R)
elif (x1, y1) == (x2, y2):
	print(x1 + R / 2, y1, R / 2)
else:
	A = y2 - y1
	B = x1 - x2
	C = -x1 * (y2 - y1) + y1 * (x2 - x1)
	if A != 0:
		A1 = A ** 2 + B ** 2
		B1 = 2 * (B * C + A * B * x1 - A ** 2 * y1)
		C1 = A ** 2 * (x1 ** 2 + y1 ** 2 - R ** 2) + C ** 2 + 2 * A * C * x1
		D = B1 ** 2 - 4 * A1 * C1
		Y1 = (-B1 + sqrt(D)) / (2 * A1)
		Y2 = (-B1 - sqrt(D)) / (2 * A1)
		X1 = (-B * Y1 - C) / A
		X2 = (-B * Y2 - C) / A
		h1 = hypot(x2 - X1, y2 - Y1)
		h2 = hypot(x2 - X2, y2 - Y2)
		if h1 > h2:
			print((x2 + X1) / 2, (y2 + Y1) / 2, h1 / 2)
		else:
			print((x2 + X2) / 2, (y2 + Y2) / 2, h2 / 2)
	elif B != 0:
		A1 = A ** 2 + B ** 2
		B1 = 2 * (A * C + A * B * y1 - B ** 2 * x1)
		C1 = B ** 2 * (x1 ** 2 + y1 ** 2 - R ** 2) + C ** 2 + 2 * B * C * y1
		D = B1 ** 2 - 4 * A1 * C1
		X1 = (-B1 + sqrt(D)) / (2 * A1)
		X2 = (-B1 - sqrt(D)) / (2 * A1)
		Y1 = (-A * X1 - C) / B
		Y2 = (-A * X2 - C) / B
		h1 = hypot(x2 - X1, y2 - Y1)
		h2 = hypot(x2 - X2, y2 - Y2)
		if h1 > h2:
			print((x2 + X1) / 2, (y2 + Y1) / 2, h1 / 2)
		else:
			print((x2 + X2) / 2, (y2 + Y2) / 2, h2 / 2)
	else:
		exit(100500)


def d(x, y):
	return (x ** 2 + y ** 2) ** 0.5

def normvec(x, y):
	if x == 0 and y == 0:
		return [1.0, 0.0]
	return [x / d(x, y), y / d(x, y)]
(r, x1, y1, x2, y2) = [int(s) for s in input().split()]
x3 = y3 = r3 = 0
r3 = (r + d(x2 - x1, y2 - y1)) / 2
(dx, dy) = normvec(x2 - x1, y2 - y1)
x3 = -dx * (r - r3) + x1
y3 = -dy * (r - r3) + y1
if d(x2 - x1, y2 - y1) > r:
	print(x1 * 1.0, y1 * 1.0, r * 1.0)
else:
	print(x3, y3, r3)


import math
l = list(map(int, input().split()))
R = l[0]
x1 = l[1]
y1 = l[2]
x2 = l[3]
y2 = l[4]
d = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if d >= R:
	print(x1, y1, R)
else:
	if x2 - x1 == 0:
		x3 = x1
		y3_1 = y1 + R
		y3_2 = y1 - R
		d1 = abs(y3_1 - y2)
		d2 = abs(y3_2 - y2)
		if d1 > d2:
			y3 = (y3_1 + y2) / 2
			r = d1 / 2
		else:
			y3 = (y3_2 + y2) / 2
			r = d2 / 2
	else:
		m = (y2 - y1) / (x2 - x1)
		c = y1 - m * x1
		Q = (x1 + m * y1 - m * c) ** 2 - (m * m + 1) * (y1 * y1 - R * R + x1 * x1 - 2 * c * y1 + c * c)
		x3_1 = (x1 + m * y1 - m * c + math.sqrt(Q)) / (m * m + 1)
		y3_1 = m * x3_1 + c
		x3_2 = (x1 + m * y1 - m * c - math.sqrt(Q)) / (m * m + 1)
		y3_2 = m * x3_2 + c
		d1 = math.sqrt((x3_1 - x2) ** 2 + (y3_1 - y2) ** 2)
		d2 = math.sqrt((x3_2 - x2) ** 2 + (y3_2 - y2) ** 2)
		if d1 > d2:
			x3 = (x3_1 + x2) / 2
			y3 = (y3_1 + y2) / 2
			r = d1 / 2
		else:
			x3 = (x3_2 + x2) / 2
			y3 = (y3_2 + y2) / 2
			r = d2 / 2
	print(x3, y3, r)


import cmath as m
(r0, x1, y1, x2, y2) = map(int, input().split())
d = (x2 - x1) ** 2 + (y2 - y1) ** 2
if d < r0 ** 2:
	r = (r0 + d ** 0.5) / 2
	x = x2
	y = y2
	if x1 == x2:
		dx = 0
		dy = r
	else:
		k = (y1 - y2) / (x1 - x2)
		k = m.atan(k)
		dx = r * abs(m.cos(k).real)
		dy = r * abs(m.sin(k).real)
	if y1 > y2:
		y += dy
	else:
		y -= dy
	if x1 > x2:
		x += dx
	else:
		x -= dx
else:
	r = r0
	x = x1
	y = y1
print(x, y, r)


x = input().split()
x = [int(i) for i in x]
d = ((x[1] - x[3]) ** 2 + (x[2] - x[4]) ** 2) ** 0.5
if d != 0:
	cos = (x[1] - x[3]) / d
	sin = (x[2] - x[4]) / d
	if d < x[0]:
		print(x[3] + (d + x[0]) / 2 * cos, x[4] + (d + x[0]) / 2 * sin, (d + x[0]) / 2)
	else:
		print(x[1], x[2], x[0])
else:
	print(x[1] + x[0] / 2, x[2], x[0] / 2)


import math
par = input()

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

def setap(R, x1, y1, x2, y2):
	d = dist(x1, y1, x2, y2)
	if d < R and d > 0:
		r = (d + R) / 2
		x = x2 - r / d * (x2 - x1)
		y = y2 - r / d * (y2 - y1)
	elif d == 0:
		x = x2 + R / 2
		y = y2
		r = R / 2
	else:
		r = R
		x = x1
		y = y1
	return [x, y, r]
par = list(map(int, par.split()))
R = par[0]
x1 = par[1]
y1 = par[2]
x2 = par[3]
y2 = par[4]
res = setap(R, x1, y1, x2, y2)
print(res[0], res[1], res[2])


(r, x1, y1, x2, y2) = input().split()
r = int(r)
x1 = int(x1)
y1 = int(y1)
x2 = int(x2)
y2 = int(y2)
ar = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if ar > r:
	print(x1, y1, r, sep=' ')
	exit(0)
if ar == 0:
	print((x1 + x1 + r) / 2, y1, r / 2, sep=' ')
	exit(0)
rr = ar + r
x3 = x2 + (x1 - x2) * rr / ar
y3 = y2 + (y1 - y2) * rr / ar
print((x3 + x2) / 2, (y3 + y2) / 2, rr / 2, sep=' ')


import sys
import math

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

def solve(io):
	(R, c_x, c_y, mate_x, mate_y) = (io.readInt(), io.readInt(), io.readInt(), io.readInt(), io.readInt())
	distance = dist(c_x, c_y, mate_x, mate_y)
	if distance >= R:
		io.print(c_x)
		io.print(' ')
		io.print(c_y)
		io.print(' ')
		io.print(R)
		return
	if distance == 0:
		c_x = c_x + R / 2.0
		R = R / 2.0
		io.print(c_x)
		io.print(' ')
		io.print(c_y)
		io.print(' ')
		io.print(R)
		return
	distance = dist(c_x, c_y, mate_x, mate_y)
	remain = distance + R
	new_radius = remain / 2.0
	vector = ((c_x - mate_x) / distance * new_radius, (c_y - mate_y) / distance * new_radius)
	center = (mate_x + vector[0], mate_y + vector[1])
	io.print(center[0])
	io.print(' ')
	io.print(center[1])
	io.print(' ')
	io.print(new_radius)

class IO:
	input = None
	output = None
	raw = ''
	buf = []
	pos = 0

	def __init__(self, inputStream, outputStream):
		self.input = inputStream
		self.output = outputStream

	def readToBuffer(self):
		self.raw = self.input.readline().rstrip('\n')
		self.buf = self.raw.split()
		self.pos = 0

	def readString(self):
		while self.pos == len(self.buf):
			self.readToBuffer()
		ans = self.buf[self.pos]
		self.pos += 1
		return ans

	def readInt(self):
		return int(self.readString())

	def readFloat(self):
		return float(self.readString())

	def readStringArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readString())
		return arr

	def readIntArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readInt())
		return arr

	def readFloatArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readFloat())
		return arr

	def readLine(self):
		while self.pos == len(self.buf):
			self.readToBuffer()
		if self.pos > 0:
			raise ValueError('Cannot call readline in the middle of a line.')
		return self.raw

	def print(self, s):
		self.output.write(str(s))

	def println(self, s):
		self.print(s)
		self.print('\n')

	def flushOutput(self):
		self.output.flush()
pythonIO = IO(sys.stdin, sys.stdout)
solve(pythonIO)
pythonIO.flushOutput()


(r, x1, y1, x2, y2) = (float(x) for x in input().split())
l = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if l > r:
	print(x1, y1, r)
else:
	if l != 0:
		cos_a = (x1 - x2) / l
		sin_a = (y1 - y2) / l
	else:
		cos_a = 1
		sin_a = 0
	l += r
	x = x2 + cos_a * (l / 2)
	y = y2 + sin_a * (l / 2)
	print(x, y, l / 2)


(r, x1, y1, x2, y2) = map(int, input().split())
x = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
if x > r:
	print(x1, y1, r)
elif x == 0:
	print(x1 + r / 2, y1, r / 2)
else:
	x3 = x2 + (x1 - x2) * (r + x) / (2 * x)
	y3 = y2 + (y1 - y2) * (r + x) / (2 * x)
	print(x3, y3, (r + x) / 2)


(R, x1, y1, x2, y2) = list(map(float, input().split()))
d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
if d > R:
	print(x1, ' ', y1, ' ', R)
elif d == 0:
	print(x1 - R / 2, ' ', y1, ' ', R / 2)
else:
	(x, y) = ((x1 * (R + d) - x2 * R) / d, (y1 * (R + d) - y2 * R) / d)
	(xans, yans) = ((x + x2) / 2, (y + y2) / 2)
	r = ((x - xans) ** 2 + (y - yans) ** 2) ** 0.5
	print(xans, ' ', yans, ' ', r)


def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def abss(x, y):
	return (x ** 2 + y ** 2) ** 0.5

def norm(x, y):
	a = abss(x, y)
	return (x / a, y / a)
(R, x1, y1, x2, y2) = mi()
if (y2 - y1) ** 2 + (x2 - x1) ** 2 >= R * R:
	ans = (x1, y1, R)
elif (x1, y1) == (x2, y2):
	ans = (x1, y1 - R / 2, R / 2)
else:
	(dx, dy) = (x1 - x2, y1 - y2)
	d = R + abss(dx, dy)
	d /= 2
	(dx, dy) = norm(dx, dy)
	x3 = x2 + dx * d
	y3 = y2 + dy * d
	ans = (x3, y3, d)
print('{:.8f} {:.8f} {:.8f}'.format(*ans))


import math
import sys

def solve(io):
	R = io.readFloat()
	X1 = io.readFloat()
	Y1 = io.readFloat()
	X2 = io.readFloat()
	Y2 = io.readFloat()
	back = (X1 - X2, Y1 - Y2)
	if back == (0, 0):
		rad = R / 2
		center = (X1 + R / 2, Y1)
	else:
		mag = min(R, magnitude(back))
		rad = (R + mag) / 2
		center = add((X2, Y2), scale(back, rad / mag))
	io.println('{0:.16f} {1:.16f} {2:.16f}'.format(center[0], center[1], rad))

def magnitude(v):
	return math.hypot(v[0], v[1])

def scale(v, s):
	return tuple(map(lambda x: s * x, v))

def add(u, v):
	return (u[0] + v[0], u[1] + v[1])

class IO:
	input = None
	output = None
	raw = ''
	buf = []
	pos = 0

	def __init__(self, inputStream, outputStream):
		self.input = inputStream
		self.output = outputStream

	def readToBuffer(self):
		self.raw = self.input.readline().rstrip('\n')
		self.buf = self.raw.split()
		self.pos = 0

	def readString(self):
		while self.pos == len(self.buf):
			self.readToBuffer()
		ans = self.buf[self.pos]
		self.pos += 1
		return ans

	def readInt(self):
		return int(self.readString())

	def readFloat(self):
		return float(self.readString())

	def readStringArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readString())
		return arr

	def readIntArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readInt())
		return arr

	def readFloatArray(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.readFloat())
		return arr

	def readLine(self):
		while self.pos == len(self.buf):
			self.readToBuffer()
		if self.pos > 0:
			raise ValueError('Cannot call readline in the middle of a line.')
		return self.raw

	def print(self, s):
		self.output.write(str(s))

	def println(self, s):
		self.print(s)
		self.print('\n')

	def flushOutput(self):
		self.output.flush()
pythonIO = IO(sys.stdin, sys.stdout)
solve(pythonIO)
pythonIO.flushOutput()


import math

def dist(x1, y1, x2, y2):
	return math.sqrt(distsqr(x1, y1, x2, y2))

def distsqr(x1, y1, x2, y2):
	return (x1 - x2) ** 2 + (y1 - y2) ** 2
(r, x1, y1, x2, y2) = map(int, input().split())
eps = 1e-16
d = distsqr(x1, y1, x2, y2)
if d >= r * r:
	print(x1, y1, r)
elif d == 0:
	print(x1 + r / 2, y1, r / 2)
else:
	d = math.sqrt(d)
	resr = (d + r) / 2
	xr = x2 - resr * (x2 - x1) / d
	yr = y2 - resr * (y2 - y1) / d
	print(xr, yr, resr)


(R, x1, y1, x2, y2) = map(int, input().split())
d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
r = (R + d) / 2
if d > R:
	print(x1, y1, R)
elif d == 0:
	print(x1 + r, y1, r)
else:
	k = r / d - 1
	print(x1 + (x1 - x2) * k, y1 + (y1 - y2) * k, r)


import math

def dist(x, y, x2, y2):
	return math.sqrt((x - x2) ** 2 + (y - y2) ** 2)
(r, cx, cy, nx, ny) = map(float, input().split())
d = (dist(nx, ny, cx, cy) + r) / 2
if dist(cx, cy, nx, ny) != 0:
	sin_alpha = abs(cy - ny) / dist(cx, cy, nx, ny)
	cos_alpha = abs(cx - nx) / dist(cx, cy, nx, ny)
	_y = d * sin_alpha
	_x = d * cos_alpha
else:
	print(cx - d, cy, d)
	exit(0)
rx = 0
ry = 0
if nx < cx:
	if ny < cy:
		rx = nx + _x
		ry = ny + _y
	else:
		rx = nx + _x
		ry = ny - _y
elif ny < cy:
	rx = nx - _x
	ry = ny + _y
else:
	rx = nx - _x
	ry = ny - _y
if (nx - cx) ** 2 + (ny - cy) ** 2 > r * r:
	print(cx, cy, r)
else:
	print(rx, ry, d)


import sys
from math import sqrt
(r, x1, y1, x2, y2) = input().split()
r = float(r)
x1 = float(x1)
x2 = float(x2)
y1 = float(y1)
y2 = float(y2)
ch = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) - r * r
if ch >= 0:
	print(x1, y1, r)
	sys.exit(0)
d = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
if d == 0:
	print(x1 + r / 2, y1, r / 2)
	sys.exit(0)
cos = (x1 - x2) / d
sin = (y1 - y2) / d
x = (x1 + r * cos + x2) / 2
y = (y1 + r * sin + y2) / 2
rans = sqrt((x - x2) * (x - x2) + (y2 - y) * (y2 - y))
print(x, y, rans)


import math

def chef(s):
	s = list(map(int, s))
	(R, x1, y1, x2, y2) = (s[0], s[1], s[2], s[3], s[4])
	dist = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	if dist >= R:
		return (x1, y1, R)
	(x_, y_) = (x2 - x1, y2 - y1)
	r = (dist + R) / 2
	if y_ == 0 and x_ == 0:
		y3 = y1 + R
		dx = x1
		dy = (y1 + y3) / 2
		return (dx, dy, R / 2)
	if x_ == 0:
		if y2 < y1:
			y3 = y2 + R + dist
			dx = x1
			dy = (y3 + y2) / 2
		else:
			y3 = y2 - (R + dist)
			dx = x1
			dy = (y3 + y2) / 2
		return (dx, dy, r)
	if y_ == 0:
		if x2 < x1:
			x3 = x2 + R + dist
			dy = y1
			dx = (x3 + x2) / 2
		else:
			x3 = x2 - (R + dist)
			dy = y1
			dx = (x3 + x2) / 2
		return (dx, dy, r)
	m = y_ / x_
	dx2 = math.sqrt(r ** 2 / (1 + m ** 2)) + x2
	dy2 = y2 + m * (dx2 - x2)
	if x2 < x1 and y2 < y1:
		if dx2 < x1 or dx2 < y1:
			dx2 = -math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
		if math.sqrt((dx2 - x1) ** 2 + (dy2 - y1) ** 2) > R:
			dx2 = math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
	elif x2 > x1 and y2 < y1:
		if dx2 > x1 or dx2 < y1:
			dx2 = -math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
		if math.sqrt((dx2 - x1) ** 2 + (dy2 - y1) ** 2) > R:
			dx2 = math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
	elif x2 < x1 and y2 > y1:
		if dx2 < x1 or dx2 > y1:
			dx2 = -math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
		if math.sqrt((dx2 - x1) ** 2 + (dy2 - y1) ** 2) > R:
			dx2 = math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
	elif x2 > x1 and y2 > y1:
		if dx2 > x1 or dx2 > y1:
			dx2 = -math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
		if math.sqrt((dx2 - x1) ** 2 + (dy2 - y1) ** 2) > R:
			dx2 = math.sqrt(r ** 2 / (1 + m ** 2)) + x2
			dy2 = y2 + m * (dx2 - x2)
	return (dx2, dy2, r)

def main():
	s = input().split()
	(x, y, r) = chef(s)
	print(str(x) + ' ' + str(y) + ' ' + str(r))
main()


import math as ma
(r, x1, y1, x2, y2) = list(map(int, input().split()))
a = ma.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if a >= r:
	print(x1, y1, r)
elif a == 0:
	print(x1 + r / 2, y1, r / 2)
else:
	b = (a + r) / 2
	c = (y2 - y1) / a
	d = (x2 - x1) / a
	print(x2 - d * b, y2 - b * c, b)


(R, x1, y1, x2, y2) = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
dlen = (dx ** 2 + dy ** 2) ** 0.5
if dlen < R:
	if dlen == 0.0:
		ax = x1 - R
		ay = y1
	else:
		ax = x1 - dx * R / dlen
		ay = y1 - dy * R / dlen
	x = (ax + x2) / 2
	y = (ay + y2) / 2
	r = (R + dlen) / 2
else:
	x = x1
	y = y1
	r = R
print('{:.15f} {:.15f} {:.15f}'.format(x, y, r))


from math import sqrt
(R, x1, y1, x2, y2) = map(int, input().split())
s = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
r = (R + s) / 2
if s > R:
	print(x1, y1, R)
elif s:
	k = r / s
	print(x2 + (x1 - x2) * k, y2 + (y1 - y2) * k, r)
else:
	print(x2 + r, y2, r)


(R, x0, y0, xf, yf, *_) = map(int, input().split(' '))
if (xf - x0) ** 2 + (yf - y0) ** 2 < R ** 2:
	v = complex(x0 - xf, y0 - yf)
	if abs(v) < 1e-06:
		v = 1 + 0j
		r = R / 2
		(x, y) = (x0 + r, y0)
	else:
		d = R + abs(v)
		r = d / 2
		a = complex(xf, yf) + v * r / abs(v)
		(x, y) = (a.real, a.imag)
else:
	(x, y, r) = (x0, y0, R)
print('%.8f %.8f %.8f' % (x, y, r))


import math
(ra, xa, ya, xb, yb) = map(float, input().split())
dis = math.sqrt(abs(xa - xb) * abs(xa - xb) + abs(ya - yb) * abs(ya - yb))
if xa == xb and ya == yb:
	print(xa)
	print(ya + ra / 2)
	print(ra / 2)
elif dis < ra:
	rb = (ra + dis) / 2
	blx = (xa - xb) / dis
	xc = xa + (rb - dis) * blx
	bly = (ya - yb) / dis
	yc = ya + (rb - dis) * bly
	print(xc)
	print(yc)
	print(rb)
else:
	print(xa)
	print(ya)
	print(ra)


a = input()
(a, b, c, d, e) = [*map(int, a.split(' '))]
f = ((e - c) ** 2 + (d - b) ** 2) ** 0.5
g = (a + f) / 2
h = a - g
if f != 0:
	if h >= 0:
		i = (b * (h + f) - h * d) / f
		j = (c * (h + f) - h * e) / f
	else:
		i = b
		j = c
		g = a
else:
	i = b + a / 2
	j = c
print(i, j, g)


(R, x1, y1, x2, y2) = map(int, input().split())
r2 = (x1 - x2) ** 2 + (y1 - y2) ** 2
if r2 >= R ** 2:
	print(x1, y1, R)
elif y1 == y2:
	r = (R + abs(x1 - x2)) / 2
	b = y1
	if x1 < x2:
		a = x2 - r
	else:
		a = x2 + r
	print(a, b, r)
elif x1 == x2:
	r = (R + abs(y1 - y2)) / 2
	a = x1
	if y1 < y2:
		b = y2 - r
	else:
		b = y2 + r
	print(a, b, r)
else:
	r = R + r2 ** (1 / 2)
	r /= 2
	r1 = r - r2 ** (1 / 2)
	tg = abs((y1 - y2) / (x1 - x2))
	a2 = r1 ** 2 / (1 + tg ** 2)
	b2 = r1 ** 2 - a2
	a2 = a2 ** (1 / 2)
	b2 = b2 ** (1 / 2)
	if x2 > x1:
		a2 = -a2
	if y2 > y1:
		b2 = -b2
	a2 += x1
	b2 += y1
	print(a2, b2, r)


import math
inp = [int(x) for x in input().split()]
R = inp[0]
x1 = inp[1]
y1 = inp[2]
x2 = inp[3]
y2 = inp[4]
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if d >= R:
	print(x1, y1, R)
elif d < 10 ** (-6):
	x3 = x2 - R / 2.0
	y3 = y2
	print(x3, y3, R / 2.0)
else:
	r = (d + R) / 2.0
	x3 = (1.0 - r / d) * x2 + r / d * x1
	y3 = (1.0 - r / d) * y2 + r / d * y1
	print(x3, y3, r)


import math
(r, x1, y1, x2, y2) = input().split()
(r, x1, y1, x2, y2) = (float(r), float(x1), float(y1), float(x2), float(y2))
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if d > r:
	print(x1, y1, r)
elif d == 0:
	print(x1 + r / 2, y1, r / 2)
else:
	R = (r + d) / 2
	dist = (r - d) / 2
	X = x1 - (x2 - x1) / d * dist
	Y = y1 - (y2 - y1) / d * dist
	print(X, Y, R)


import math
EPS = 1e-10

def point_in_angle(a, o, b, p):
	op = do_vector(p, o)
	oa = do_vector(a, o)
	ob = do_vector(b, o)
	bo = do_vector(o, b)
	bp = do_vector(p, b)
	ba = do_vector(a, b)
	ao = do_vector(o, a)
	ap = do_vector(p, a)
	ab = do_vector(b, a)
	if (op ^ oa) * (op ^ ob) <= 0 and (bp ^ bo) * (ba ^ bo) >= 0 and ((ap ^ ao) * (ab ^ ao) >= 0):
		return True
	else:
		return False

def check_common_segments(A, B, C, D):
	line1 = line_with_to_points(A, B)
	line2 = line_with_to_points(C, D)
	if function_line(C, line1) * function_line(D, line1) < EPS and function_line(A, line2) * function_line(B, line2) < EPS:
		return 'YES'
	elif abs(function_line(C, line1)) <= EPS and abs(C.length(A) + C.length(B) - A.length(B)) <= EPS:
		return 'YES'
	elif abs(function_line(D, line1)) <= EPS and abs(D.length(A) + D.length(B) - A.length(B)) <= EPS:
		return 'YES'
	elif abs(function_line(A, line2)) <= EPS and abs(A.length(C) + A.length(D) - C.length(D)) <= EPS:
		return 'YES'
	elif abs(function_line(B, line1)) <= EPS and abs(B.length(C) + B.length(D) - C.length(D)) <= EPS:
		return 'YES'
	else:
		return 'NO'

def length_to_ray(point1, point2, point3):
	(x, y) = (point1.x, point1.y)
	(x1, y1) = (point2.x, point2.y)
	(x2, y2) = (point3.x, point3.y)
	if do_vector(point(x, y), point(x1, y1)) * do_vector(point(x2, y2), point(x1, y1)) >= 0:
		return high(do_vector(point(x1, y1), point(x, y)), do_vector(point(x2, y2), point(x, y)), point(x2, y2).length(point(x1, y1)))
	else:
		return min(point(x, y).length(point(x1, y1)), point(x, y).length(point(x2, y2)))

def point_on_circle(circle1, point1):
	if abs((point1.x - circle1.x) ** 2 + (point1.y - circle1.y) ** 2 - circle1.radius ** 2) < EPS:
		return True
	return False

def check(point1, point2):
	if abs(point1.x - point2.x) < EPS and abs(point1.y - point2.y) < EPS:
		return True
	return False

def function_line(point1, line1):
	return line1.a * point1.x + line1.b * point1.y + line1.c

def normal_vector(line, point):
	return vector(line.a, line.b).multiply(-2 * function_line(point, line) / (line.a ** 2 + line.b ** 2))

def normalize(vec):
	x = vec.x / vec.length()
	y = vec.y / vec.length()
	return vector(x, y)

def line_with_to_points(point1, point2):
	a = point2.y - point1.y
	b = point1.x - point2.x
	c = -(a * point1.x + b * point1.y)
	return line(a, b, c)

def common_point(line1, line2):
	if line1.b == 0:
		(line1, line2) = (line2, line1)
	if line1.b != 0 and line1.b * line2.a - line2.b * line1.a != 0:
		x = (line2.b * line1.c - line1.b * line2.c) / (line1.b * line2.a - line2.b * line1.a)
		y = (-line1.c - line1.a * x) / line1.b
		return point(x, y)
	else:
		return point(-1e+18 - 7, -1e+18 - 9)

def from_radian_to_degrees(angle):
	return angle * 180 / math.pi

def point_with_fixed_ratio(point1, point2, a, b):
	x = (point2.x - point1.x) * a / (a + b) + point1.x
	y = point2.y + (point1.y - point2.y) * b / (a + b)
	return point(x, y)

def high(vector1, vector2, length):
	return abs((vector1 ^ vector2) / length)

def do_vector(point1, point2):
	return vector(point1.x - point2.x, point1.y - point2.y)

def s_triangle(first, second, angle):
	return first * second * math.sin(angle) / 2

def s_sector(angle, radius):
	return angle / (2 * math.pi) * math.pi * radius ** 2

class point:

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

	def length(self, other):
		return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

	def __eq__(self, other):
		if self.x == other.x and self.y == other.y:
			return True
		return False

class vector:

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

	def turn(self, sina, cosa):
		x = self.x * cosa + self.y * sina
		y = -self.x * sina + self.y * cosa
		return vector(x, y)

	def multiply(self, number):
		return vector(self.x * number, self.y * number)

	def __mul__(self, other):
		return self.x * other.x + self.y * other.y

	def __xor__(self, other):
		return self.x * other.y - other.x * self.y

	def polar_angle(self):
		return math.atan2(self.y, self.x)

	def angle(self, other):
		return math.atan2(self ^ other, self * other)

	def length(self):
		return (self.x ** 2 + self.y ** 2) ** 0.5

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

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

class circle:

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

	def __eq__(self, other):
		if self.x == other.x and self.y == other.y and (self.radius == other.radius):
			return True
		return False

class line:

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

	def __eq__(self, other):
		if self.x == other.x and self.y == other.y:
			return True
		return False
(R, x1, y1, x2, y2) = map(float, input().split())
O = point(x1, y1)
P = point(x2, y2)
r = (R + O.length(P)) / 2
if O.length(P) > R:
	print(x1, y1, R)
elif O.length(P) == 0:
	print(x2 + r, y2, r)
else:
	print(x2 + (x1 - x2) * (r / O.length(P)), y2 + (y1 - y2) * (r / O.length(P)), r)


from math import sqrt
(R, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 <= R * R:
	mnR = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	r = (mnR + R) / 2
	if x1 == x2 and y1 == y2:
		(x, y) = (x1 + R / 2, float(y1))
	else:
		x = (x1 - x2) * r / mnR + x2
		y = (y1 - y2) * r / mnR + y2
	print(x, y, r)
else:
	print('%.1f %.1f %.1f' % (x1, y1, R))


(r, x1, y1, x2, y2) = map(int, input().split())
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if x1 == x2 and y1 == y2:
	print(x1 + r / 2, y1, r / 2)
	quit()
if d >= r:
	print(x1, y1, r)
	quit()
print(x2 - (r + d) * (x2 - x1) / (2 * d), y2 - (r + d) * (y2 - y1) / (2 * d), (r + d) / 2)


import math
(r, x1, y1, x2, y2) = map(int, input().strip().split(' '))
if math.hypot(abs(x1 - x2), abs(y1 - y2)) >= r:
	print(x1, y1, r)
else:
	theta = math.atan2(y1 - y2, x1 - x2)
	x = x1 + r * math.cos(theta)
	y = y1 + r * math.sin(theta)
	ax = (x + x2) / 2.0
	ay = (y + y2) / 2.0
	d = math.hypot(abs(ax - x2), abs(ay - y2))
	print(ax, ay, d)


import math

def main():
	(r1, x1, y1, x2, y2) = (int(x) for x in input().split())
	if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r1 ** 2:
		print(x1, y1, r1)
		return
	v1 = (x1 - x2, y1 - y2)
	len_v1 = math.sqrt(v1[0] ** 2 + v1[1] ** 2)
	r = (r1 + len_v1) / 2
	if (x1, y1) == (x2, y2):
		print(v1[0] + x2, v1[1] + r + y2, r)
		return
	k = (r1 + len_v1) / 2 / len_v1
	v_res = (v1[0] * k + x2, v1[1] * k + y2)
	print(v_res[0], v_res[1], r)
main()


(R, x1, y1, x2, y2) = map(int, input().split())
p1 = x1 + y1 * 1j
p2 = x2 + y2 * 1j
if abs(p2 - p1) > R:
	print(x1, y1, R)
elif p2 == p1:
	print(x1 + R / 2, y1, R / 2)
else:
	v = (p1 - p2) / abs(p1 - p2)
	p3 = p1 + v * R
	p4 = (p3 + p2) / 2
	print(p4.real, p4.imag, abs(p4 - p2))


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = 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(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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(r, x1, y1, x2, y2) = map(int, input().split())
if (x1 - x2) ** 2 + (y1 - y2) ** 2 > r * r:
	print(x1, y1, r)
	exit()
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
r2 = (r + d) / 2
if d == 0:
	x3 = x2 + r / 2
	y3 = y2
else:
	x3 = x2 + (x1 - x2) / d * r2
	y3 = y2 + (y1 - y2) / d * r2
print(x3, y3, r2)


import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
(R, x1, y1, x2, y2) = mints()
if x1 == x2 and y1 == y2:
	print(x1 + R / 2, y1, R / 2)
elif (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R * R:
	print(x1, y1, R)
else:
	r1 = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	r = (R + r1) / 2
	print(x2 + (x1 - x2) * r / r1, y2 + (y1 - y2) * r / r1, r)


(R, x1, y1, x2, y2) = map(int, input().split(' '))
d1 = (x2 - x1) ** 2 + (y2 - y1) ** 2
if d1 >= R * R:
	print(str(x1) + ' ' + str(y1) + ' ' + str(R))
else:
	d2 = R + d1 ** 0.5
	if x1 == x2 and y1 == y2:
		print(str(x1 + R / 2) + ' ' + str(y1) + ' ' + str(d2 / 2))
	elif x1 == x2:
		if y2 > y1:
			print(str(x1) + ' ' + str((y1 + y2 - R) / 2) + ' ' + str(d2 / 2))
		else:
			print(str(x1) + ' ' + str((y1 + y2 + R) / 2) + ' ' + str(d2 / 2))
	elif y1 == y2:
		if x2 > x1:
			print(str((x1 + x2 - R) / 2) + ' ' + str(y1) + ' ' + str(d2 / 2))
		else:
			print(str((x1 + x2 + R) / 2) + ' ' + str(y1) + ' ' + str(d2 / 2))
	else:
		x2 -= x1
		y2 -= y1
		slp = y2 / x2
		a = (R * R / (slp * slp + 1)) ** 0.5
		b = slp * a
		if x2 < 0:
			print(str((a + x2) / 2 + x1) + ' ' + str((y2 + b) / 2 + y1) + ' ' + str(d2 / 2))
		else:
			print(str((x2 - a) / 2 + x1) + ' ' + str((y2 - b) / 2 + y1) + ' ' + str(d2 / 2))


(R, x1, y1, x2, y2) = input().split()
R = float(R)
x1 = float(x1)
y1 = float(y1)
x2 = float(x2)
y2 = float(y2)
d = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
k1 = d
k2 = (R - d) / 2
if d == 0:
	print(x1 + R / 2, y1, R / 2)
elif d <= R:
	print((x1 * (k1 + k2) - k2 * x2) / k1, (y1 * (k1 + k2) - k2 * y2) / k1, (R + d) / 2)
else:
	print(x1, y1, R)


import sys, math

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

def main():
	p = sys.stdin.readline()
	if p == '':
		return
	(r, x1, y1, x2, y2) = map(float, p.split(' '))
	l = suan(x1, y1, x2, y2)
	if l >= r ** 2:
		print(x1, y1, r)
	elif x1 == x2 and y1 == y2:
		print(x1 + 0.5 * r, y1, r * 0.5)
	else:
		a = math.sqrt(l)
		b = (a + r) * 0.5
		print((x1 - x2) * b / a + x2, (y1 - y2) * b / a + y2, b)
main()


import sys
(R, x1, y1, x2, y2) = map(int, input().split())
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if d > R:
	print(x1, y1, R)
elif d == 0:
	print(x1 - R / 2, y1, R / 2)
else:
	r = (R + d) / 2
	x = x2 + (x1 - x2) / d * r
	y = y2 + (y1 - y2) / d * r
	print(x, y, r)


def generate_M_C(xr, yr, xl, yl):
	global m
	m = float(yr - yl) / float(xr - xl)
	global c
	c = yr - xr * m

def get_point_on_circle1(xr, yr, radius):
	y = yr - (radius ** 2 / ((1.0 / m) ** 2 + 1)) ** 0.5
	x = 1.0 / m * (y - yr) + xr
	return [x, y]

def get_point_on_circle2(xr, yr, radius):
	y = yr + (radius ** 2 / ((1.0 / m) ** 2 + 1)) ** 0.5
	x = 1.0 / m * (y - yr) + xr
	return [x, y]

def get_center(xc, yc, xl, yl):
	return (float(xl + xc) / 2, float(yl + yc) / 2)

def get_rad(xc, yc, xl, yl):
	rad = ((xc - xl) ** 2 + (yc - yl) ** 2) ** 0.5 / 2.0
	return rad

def main():
	x = input().split()
	R = float(x[0])
	xr = float(x[1])
	yr = float(x[2])
	xl = float(x[3])
	yl = float(x[4])
	if get_rad(xl, yl, xr, yr) * 2 >= R:
		print(xr, yr, R)
	elif float(yr - yl) != 0 and float(xr - xl) != 0:
		generate_M_C(xr, yr, xl, yl)
		(XC1, YC1) = get_point_on_circle1(xr, yr, R)
		(XC2, YC2) = get_point_on_circle2(xr, yr, R)
		if get_rad(XC2, YC2, xl, yl) > get_rad(XC1, YC1, xl, yl):
			(a, b) = get_center(XC2, YC2, xl, yl)
			print(str(a) + ' ' + str(b) + ' ' + str(get_rad(XC2, YC2, xl, yl)))
		else:
			(a, b) = get_center(XC1, YC1, xl, yl)
			print(str(a) + ' ' + str(b) + ' ' + str(get_rad(XC1, YC1, xl, yl)))
	elif float(yr - yl) == 0 and xr == xl:
		(a, b) = (xr + R / 2.0, yr)
		print(float(a), end=' ')
		print(float(b), end=' ')
		print(R / 2.0)
	elif float(yr - yl) == 0:
		if xr > xl:
			XC = xr + R
			YC = yr
		else:
			XC = xr - R
			YC = yr
		(a, b) = get_center(XC, YC, xl, yl)
		print(float(a), end=' ')
		print(float(b), end=' ')
		print(float(get_rad(XC, YC, xl, yl)))
	elif float(xr - xl) == 0:
		if yr > yl:
			YC = yr + R
			XC = xr
		else:
			YC = yr - R
			XC = xr
		(a, b) = get_center(XC, YC, xl, yl)
		print(float(a), end=' ')
		print(float(b), end=' ')
		print(float(get_rad(XC, YC, xl, yl)))
main()


import math as mt
import itertools as it
import functools as ft
import random as rnd
stdin = lambda type_='int', sep=' ': list(map(eval(type_), input().split(sep)))
joint = lambda sep=' ', *args: sep.join((str(i) if type(i) != list else sep.join(map(str, i)) for i in args))
(R, x1, y1, x2, y2) = stdin()
if x1 == x2 and y1 == y2:
	print('{} {} {}'.format(x1 + R / 2.0, y1, R / 2.0))
elif (x2 - x1) ** 2 + (y2 - y1) ** 2 >= R ** 2:
	print('{} {} {}'.format(x1, y1, R))
else:
	dist = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
	tochka = [x2 + (x1 - x2) * (dist + R) / dist, y2 + (y1 - y2) * (dist + R) / dist]
	print('{} {} {}'.format((tochka[0] + x2) / 2, (tochka[1] + y2) / 2, ((tochka[0] - x2) ** 2 + (tochka[1] - y2) ** 2) ** 0.5 / 2))


import math
(R, x0, y0, x1, y1) = [int(x) for x in input().split()]
d1 = math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0))
f = 0
if (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0) > R * R:
	f = 1
r = (d1 + R) / 2
if x1 != x0:
	ten = (y1 - y0) / (x1 - x0)
	if ten > 0:
		if y1 > y0:
			sn = math.sin(math.atan(ten))
			ansy = y1 - sn * r
			cn = math.cos(math.atan(ten))
			ansx = x1 - cn * r
		else:
			sn = math.sin(math.atan(ten))
			ansy = y1 + sn * r
			cn = math.cos(math.atan(ten))
			ansx = x1 + cn * r
	else:
		ten = abs(ten)
		if y1 > y0:
			sn = math.sin(math.atan(ten))
			ansy = y1 - sn * r
			cn = math.cos(math.atan(ten))
			ansx = x1 + cn * r
		else:
			sn = math.sin(math.atan(ten))
			ansy = y1 + sn * r
			cn = math.cos(math.atan(ten))
			ansx = x1 - cn * r
else:
	ansx = x1
	if y1 > y0:
		ansy = y1 - r
	else:
		ansy = y1 + r
if f == 0:
	print(ansx, ansy, r)
else:
	print(x0, y0, R)


import math
from sys import stdin
string = stdin.readline().strip().split()
R = float(string[0])
x1 = float(string[1])
y1 = float(string[2])
x2 = float(string[3])
y2 = float(string[4])
output = [0, 0, 0]
dsq = abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2
if dsq >= R ** 2:
	output[0] = x1
	output[1] = y1
	output[2] = R
elif dsq == 0:
	output[0] = x1 + R / 2
	output[1] = y2
	output[2] = R / 2
else:
	if x1 == x2:
		dx = 0
	else:
		dx = (R + math.sqrt(dsq)) / 2 / math.sqrt(dsq) * abs(x1 - x2)
	if x2 < x1:
		output[0] = x2 + dx
	else:
		output[0] = x2 - dx
	if y1 == y2:
		dy = 0
	else:
		dy = (R + math.sqrt(dsq)) / 2 / math.sqrt(dsq) * abs(y1 - y2)
	if y2 < y1:
		output[1] = y2 + dy
	else:
		output[1] = y2 - dy
	output[2] = math.sqrt(dx ** 2 + dy ** 2)
for x in output:
	print(x, ' ', end='')


s = input()
l = []
l = list(map(int, s.split()))
R = l[0]
r = 0
x1 = l[1]
y1 = l[2]
x2 = l[3]
y2 = l[4]
d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
if d >= R and d != 0:
	r = R
	xa = x1
	ya = y1
if d < R and d != 0:
	r = (R + d) / 2
	xa = (x2 + ((R + d) * x1 - R * x2) / d) / 2
	ya = (y2 + ((R + d) * y1 - R * y2) / d) / 2
if d == 0:
	r = R / 2
	xa = r + x1
	ya = y1
print(xa)
print(ya)
print(r)


import sys
from math import sqrt
(r, x1, y1, x2, y2) = list(map(int, input().split()))
if x1 == x2 and y1 == y2:
	print(x1 + r / 2, y1, r / 2)
	sys.exit()
if r < sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2):
	print(x1, y1, r)
	sys.exit()
cx = x1 + r * (x1 - x2) / sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
cy = y1 + r * (y1 - y2) / sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
cx = (cx - x2) / 2 + x2
cy = (cy - y2) / 2 + y2
r1 = sqrt((cx - x2) ** 2 + (cy - y2) ** 2)
print(cx, cy, r1)


def distsq(x1, y1, x2, y2):
	return (x1 - x2) ** 2 + (y1 - y2) ** 2
(R, x1, y1, x2, y2) = [int(x) for x in input().split()]
(dx, dy) = (x2 - x1, y2 - y1)
if dx ** 2 + dy ** 2 - R ** 2 >= 0:
	print(x1, y1, R)
else:
	x = y = r = 0
	if dx == 0:
		x = 0
		if dy > 0:
			y = (dy - R) / 2
			r = dy - y
		else:
			y = (dy + R) / 2
			r = y - dy
	else:
		m = dy / dx
		a = R / (1 + m ** 2) ** 0.5
		(xn1, xn2) = (a, -a)
		(yn1, yn2) = (m * a, -m * a)
		(d1, d2) = (distsq(xn1, yn1, dx, dy), distsq(xn2, yn2, dx, dy))
		if d1 > d2:
			x = (xn1 + dx) / 2
			y = (yn1 + dy) / 2
			r = d1 ** 0.5 / 2
		else:
			x = (xn2 + dx) / 2
			y = (yn2 + dy) / 2
			r = d2 ** 0.5 / 2
	print(x + x1, y + y1, r)


import math
s = input().split()
r = int(s[0])
x1 = int(s[1])
y1 = int(s[2])
x2 = int(s[3])
y2 = int(s[4])
if (x2 - x1) ** 2 + (y2 - y1) ** 2 > r ** 2:
	print('{} {} {}'.format(x1, y1, r))
else:
	if x2 - x1 == 0:
		nx1 = x1
		nx2 = x1
		ny1 = y1 + r
		ny2 = y1 - r
	else:
		k = (y2 - y1) / (x2 - x1)
		nx1 = math.sqrt(r ** 2 / (k ** 2 + 1)) + x1
		nx2 = -math.sqrt(r ** 2 / (k ** 2 + 1)) + x1
		ny1 = k * (nx1 - x1) + y1
		ny2 = k * (nx2 - x1) + y1
	if math.sqrt((ny1 - y2) ** 2 + (nx1 - x2) ** 2) > math.sqrt((ny2 - y2) ** 2 + (nx2 - x2) ** 2):
		print('{} {} {}'.format((nx1 + x2) / 2, (ny1 + y2) / 2, math.sqrt((ny1 - y2) ** 2 + (nx1 - x2) ** 2) / 2))
	else:
		print('{} {} {}'.format((nx2 + x2) / 2, (ny2 + y2) / 2, math.sqrt((ny2 - y2) ** 2 + (nx2 - x2) ** 2) / 2))


from math import sqrt
(r, x1, y1, x2, y2) = map(int, input().split())
distance = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
if distance > r:
	print(x1, y1, r, sep=' ', end='\n')
elif distance == 0:
	print(x1 - r / 2, y1, r / 2, sep=' ', end='\n')
else:
	rap = (distance + r) / 2
	xap = x1 - (x2 - x1) * (rap / distance - 1)
	yap = y1 - (y2 - y1) * (rap / distance - 1)
	print(xap, yap, rap, sep=' ', end='\n')


import math
(R, x1, y1, x2, y2) = map(int, input().split())

def xxx(x1, x2):
	global l, l0
	if x1 > x2:
		return l * (x1 - x2) / l0 + x2
	elif x1 < x2:
		return x2 - l * (x2 - x1) / l0
	return float(y1)

def yyy(x1, x2):
	global l, l0
	if y1 > y2:
		return l * (y1 - y2) / l0 + y2
	elif y1 < y2:
		return y2 - l * (y2 - y1) / l0
	return float(y1)
if (x2 - x1) ** 2 + (y2 - y1) ** 2 > R ** 2:
	print(x1, y1, R)
elif x1 == x2 and y1 == y2:
	print(x1 + R / 2, y1, R / 2)
else:
	l = (math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) + R) / 2
	l0 = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	print(xxx(x1, x2), yyy(y1, y2), l)


from math import sqrt
(R, x1, y1, x2, y2) = [int(x) for x in input().split()]
d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if d == 0:
	print(x1 + R / 2, y1, R / 2)
elif d >= R:
	print(x1, y1, R)
else:
	r = (d + R) / 2
	print((x1 - x2) * r / d + x2, (y1 - y2) * r / d + y2, r)


(r, x1, y1, x2, y2) = map(int, input().split())
if (x1 - x2) ** 2 + (y1 - y2) ** 2 > r ** 2:
	print(x1, y1, r)
else:
	if x2 == x1:
		p1 = x1
		p2 = x1
		q1 = y1 + r
		q2 = y1 - r
	else:
		m = (y2 - y1) / (x2 - x1)
		c = y1 - m * x1
		c1 = c - y1
		a = 1 + m ** 2
		b = 2 * (m * c1 - x1)
		c2 = x1 ** 2 + c1 ** 2 - r ** 2
		p1 = (-b + (b ** 2 - 4 * a * c2) ** 0.5) / (2 * a)
		q1 = m * p1 + c
		p2 = (-b - (b ** 2 - 4 * a * c2) ** 0.5) / (2 * a)
		q2 = m * p2 + c
	r1 = ((p1 - x2) ** 2 + (q1 - y2) ** 2) ** 0.5
	r2 = ((p2 - x2) ** 2 + (q2 - y2) ** 2) ** 0.5
	if r1 >= r2:
		print((p1 + x2) / 2, (q1 + y2) / 2, r1 / 2)
	else:
		print((p2 + x2) / 2, (q2 + y2) / 2, r2 / 2)


import sys
import io, os
import math
gcd = math.gcd
ceil = math.ceil
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def dis(a, b, c, d):
	return ((a - c) * (a - c) + (b - d) * (b - d)) ** 0.5

def main():
	arr = list(map(int, input().split()))
	R = arr[0]
	x1 = arr[1]
	y1 = arr[2]
	x2 = arr[3]
	y2 = arr[4]
	a = dis(x1, y1, x2, y2)
	if a == 0:
		print(x1, y1 + R / 2, R / 2)
		exit()
	if R <= a:
		print(x1, y1, R)
	else:
		r = (R + a) / 2
		vector = [(x1 - x2) / a * 2 * r / 2 + x2, (y1 - y2) / a * 2 * r / 2 + y2]
		print(*vector, r)
main()


import math
(R, x1, y1, x2, y2) = map(int, input().split())
x2 -= x1
y2 -= y1
v = math.sqrt(x2 * x2 + y2 * y2)
if v >= R:
	print(x1, y1, R)
	quit()
if v == 0:
	print(x1 + R / 2, y1, R / 2)
	quit()
d = v + R
ans3 = d / 2
x3 = x2 + -x2 * ((v + R) / v)
y3 = y2 + -y2 * ((v + R) / v)
ans1 = x2 + (x3 - x2) * 0.5
ans2 = y2 + (y3 - y2) * 0.5
print(ans1 + x1, ans2 + y1, ans3)


from sys import stdin, stdout
from math import sqrt, inf

def dist(x1, y1, x2, y2):
	return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
(R, x1, y1, x2, y2) = map(int, stdin.readline().strip().split())
if not x2 == x1:
	m = (y2 - y1) / (x2 - x1)
else:
	m = inf
if sqrt(dist(x1, y1, x2, y2)) > R:
	(ax, ay, r) = (x1, y1, R)
else:
	if not m == inf:
		p = sqrt(1 / (1 + m * m))
		fx1 = x1 + R * p
		fx2 = x1 - R * p
		fy1 = y1 + m * R * p
		fy2 = y1 - m * R * p
	else:
		fx1 = x1
		fx2 = x1
		fy1 = y1 + R
		fy2 = y1 - R
	if dist(fx1, fy1, x2, y2) > dist(fx2, fy2, x2, y2):
		fx = fx1
		fy = fy1
	else:
		fx = fx2
		fy = fy2
	ax = (fx + x2) / 2
	ay = (fy + y2) / 2
	r = sqrt(dist(ax, ay, x2, y2))
print('{:.15f} {:.15f} {:.15f}'.format(ax, ay, r))


(R, x1, y1, x2, y2) = [int(x) for x in input().split()]
l = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if l > R:
	print(x1, y1, R)
elif x1 == x2 and y1 == y2:
	print(x1, y1 + R / 2, R / 2)
else:
	r = (l + R) / 2
	(dx, dy) = (x1 - x2, y1 - y2)
	xr = x2 + r * dx / l
	yr = y2 + r * dy / l
	print(xr, yr, r)


import sys
import os
import math
import re
(r, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r ** 2:
	print(float(x1), float(y1), float(r))
	exit(0)
angle = math.atan2(y1 - y2, x1 - x2)
dist = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) + r
finalX = dist / 2 * math.cos(angle) + x2
finalY = dist / 2 * math.sin(angle) + y2
print(finalX, finalY, dist / 2)


(R, x1, y1, x2, y2) = map(int, input().split())
if (x2 - x1) ** 2 + (y2 - y1) ** 2 > R ** 2:
	print(x1, y1, R)
	exit()
l = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
r = (R + ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5) / 2
if l != 0:
	sa = (y1 - y2) / l
	ca = (x1 - x2) / l
	print(r * ca + x2, r * sa + y2, r)
else:
	print(x1, y1 + r, r)


(R, x1, y1, x2, y2) = map(int, input().split())
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
sin = 0
cos = 1

def dist(x1, x2, y1, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if s > R:
	print(x1, y1, R)
else:
	r = (s + R) / 2
	if s != 0:
		sin = (y2 - y1) / s
		cos = (x2 - x1) / s
	(xpos, ypos) = (x2 + r * cos, y2 + r * sin)
	(xneg, yneg) = (x2 - r * cos, y2 - r * sin)
	dis1 = dist(xpos, x1, ypos, y1)
	dis2 = dist(xneg, x1, yneg, y1)
	if dis1 < dis2:
		print(xpos, ypos, r)
	else:
		print(xneg, yneg, r)


import math
(R, x1, y1, x2, y2) = map(int, input().split())
if math.hypot(x2 - x1, y2 - y1) >= R:
	print(x1, y1, R, end=' ')
else:
	angle = math.atan2(y2 - y1, x2 - x1)
	angle = angle + math.pi
	ansx = x1 + math.cos(angle) * R
	ansy = y1 + math.sin(angle) * R
	ansdist = (math.hypot(x2 - x1, y2 - y1) + R) / 2
	ansx = (ansx + x2) / 2
	ansy = (ansy + y2) / 2
	print('{0:.8f}'.format(ansx), '{0:.8f}'.format(ansy), '{0:.8f}'.format(ansdist), end=' ')


from math import sqrt
(r, x1, y1, x2, y2) = map(float, input().split())
x2 -= x1
y2 -= y1
dist = sqrt(x2 ** 2 + y2 ** 2)
if dist >= r:
	print(x1, y1, r)
else:
	rad = (r + dist) / 2.0
	if dist > 0:
		(x2norm, y2norm) = (x2 / dist, y2 / dist)
	else:
		(x2norm, y2norm) = (1.0, 0.0)
	p = (x1 + x2 + rad * -x2norm, y1 + y2 + rad * -y2norm)
	print(p[0], p[1], rad)


import os
import sys
import math
import heapq
from decimal import *
from io import BytesIO, IOBase
from collections import defaultdict, deque

def r():
	return int(input())

def rm():
	return map(int, input().split())

def rl():
	return list(map(int, input().split()))
(R, x1, y1, x2, y2) = rm()
radiusS = abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2
if radiusS >= R ** 2:
	print(x1, y1, R)
elif x1 == x2:
	Ypos1 = y1 + R
	Ypos2 = y1 - R
	if abs(Ypos1 - y2) >= abs(Ypos2 - y2):
		print(x1, (Ypos1 + y2) / 2, abs(Ypos1 - y2) / 2)
	else:
		print(x1, (Ypos2 + y2) / 2, abs(Ypos2 - y2) / 2)
else:
	Xpos1 = x1 + R * abs(x2 - x1) / math.sqrt(radiusS)
	Xpos2 = x1 - R * abs(x2 - x1) / math.sqrt(radiusS)
	Ypos1 = y1 + (y2 - y1) / (x2 - x1) * (Xpos1 - x1)
	Ypos2 = y1 + (y2 - y1) / (x2 - x1) * (Xpos2 - x1)
	if (Xpos1 - x2) ** 2 + (Ypos1 - y2) ** 2 > (Xpos2 - x2) ** 2 + (Ypos2 - y2) ** 2:
		print((Xpos1 + x2) / 2, (Ypos1 + y2) / 2, math.sqrt((Xpos1 - x2) ** 2 + (Ypos1 - y2) ** 2) / 2)
	else:
		print((Xpos2 + x2) / 2, (Ypos2 + y2) / 2, math.sqrt((Xpos2 - x2) ** 2 + (Ypos2 - y2) ** 2) / 2)


(R, x, y, s, t) = map(int, input().split())
f = lambda x, y: x * x + y * y
g = lambda x: x ** 0.5
d = f(x - s, y - t)
if not d:
	R /= 2
	x += R
elif d < R * R:
	x -= s
	y -= t
	r = g(f(x, y))
	x /= r
	y /= r
	R = (g(d) + R) / 2
	x *= R
	y *= R
	x += s
	y += t
print(x, y, R)


import math
(r, x1, y1, x2, y2) = list(map(int, input().split()))
if (x2 - x1) ** 2 + (y2 - y1) ** 2 >= r * r:
	print(x1, y1, r)
elif x1 == x2 and y1 == y2:
	print(x1, y1 - r / 2, r / 2)
elif y1 == y2:
	x01 = r + x1
	ans1x = (x01 + x2) / 2
	ans1y = (y1 + y2) / 2
	r1 = math.sqrt((ans1x - x2) ** 2 + (ans1y - y2) ** 2)
	x02 = -r + x1
	ans2x = (x02 + x2) / 2
	ans2y = (y1 + y2) / 2
	r2 = math.sqrt((ans2x - x2) ** 2 + (ans2y - y2) ** 2)
	if r1 > r2:
		print(ans1x, ans1y, r1)
	else:
		print(ans2x, ans2y, r2)
else:
	y01 = r / math.sqrt(1 + (x2 - x1) ** 2 / (y2 - y1) ** 2) + y1
	x01 = (y01 - y1) * (x2 - x1) / (y2 - y1) + x1
	ans1x = (x01 + x2) / 2
	ans1y = (y01 + y2) / 2
	r1 = math.sqrt((ans1x - x2) ** 2 + (ans1y - y2) ** 2)
	y02 = -r / math.sqrt(1 + (x2 - x1) ** 2 / (y2 - y1) ** 2) + y1
	x02 = (y02 - y1) * (x2 - x1) / (y2 - y1) + x1
	ans2x = (x02 + x2) / 2
	ans2y = (y02 + y2) / 2
	r2 = math.sqrt((ans2x - x2) ** 2 + (ans2y - y2) ** 2)
	if r1 > r2:
		print(ans1x, ans1y, r1)
	else:
		print(ans2x, ans2y, r2)


import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = 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(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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] < key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] >= k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater

class BinaryTrie:

	class Node:

		def __init__(self, bit: bool=False):
			self.bit = bit
			self.children = []
			self.count = 0
			self.counter = 1

	def __init__(self, size):
		self.root = BinaryTrie.Node()
		self.size = size

	def convert(self, key):
		bits = []
		if isinstance(key, int):
			key = bin(key)[2:]
		if isinstance(key, str):
			for i in range(self.size - len(key)):
				bits += [False]
			for i in key:
				if i == '0':
					bits += [False]
				else:
					bits += [True]
		else:
			return list(key)
		return bits

	def add(self, key):
		node = self.root
		bits = self.convert(key)
		for bit in bits:
			found_in_child = False
			for child in node.children:
				if child.bit == bit:
					child.counter += 1
					node = child
					found_in_child = True
					break
			if not found_in_child:
				new_node = BinaryTrie.Node(bit)
				node.children.append(new_node)
				node = new_node
		node.count += 1

	def remove(self, key):
		node = self.root
		bits = self.convert(key)
		nodelist = [node]
		for bit in bits:
			for child in node.children:
				if child.bit == bit:
					node = child
					node.counter -= 1
					nodelist.append(node)
					break
		node.count -= 1
		if not node.children and (not node.count):
			for i in range(len(nodelist) - 2, -1, -1):
				nodelist[i].children.remove(nodelist[i + 1])
				if nodelist[i].children or nodelist[i].count:
					break

	def query(self, prefix, root=None):
		if not root:
			root = self.root
		node = root
		if not root.children:
			return 0
		for bit in prefix:
			bit_not_found = True
			for child in node.children:
				if child.bit == bit:
					bit_not_found = False
					node = child
					break
			if bit_not_found:
				return 0
		return node

class TrieNode:

	def __init__(self):
		self.children = [None] * 26
		self.data = 0
		self.isEndOfWord = False

class Trie:

	def __init__(self):
		self.root = self.getNode()

	def getNode(self):
		return TrieNode()

	def _charToIndex(self, ch):
		return ord(ch) - ord('a')

	def insert(self, key, val):
		pCrawl = self.root
		length = len(key)
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				pCrawl.children[index] = self.getNode()
			pCrawl = pCrawl.children[index]
			pCrawl.data += val
		pCrawl.isEndOfWord = True

	def search(self, key):
		pCrawl = self.root
		length = len(key)
		c = 0
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				return c
			c += 1
			pCrawl = pCrawl.children[index]
		return c

	def present(self, key):
		ans = 0
		pCrawl = self.root
		length = len(key)
		c = 0
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				return False
			pCrawl = pCrawl.children[index]
			ans += pCrawl.data
		if pCrawl != None:
			return ans
		return -1
(R, x1, y1, x2, y2) = map(int, input().split())
d = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if d >= R:
	print(x1, y1, R)
	sys.exit(0)
r = (R + d) / 2
if x1 == x2:
	if y1 > y2:
		print(x1, y2 + r, r)
	else:
		print(x1, y2 - r, r)
	sys.exit(0)
slope = (y1 - y2) / (x1 - x2)
c = y1 - slope * x1
x = x2 + r * math.sqrt(1 / (1 + slope * slope))
xr = x2 - r * math.sqrt(1 / (1 + slope * slope))
y = y2 + slope * r * math.sqrt(1 / (1 + slope * slope))
yr = y2 - r * slope * math.sqrt(1 / (1 + slope * slope))
xw = x1 + (d - r) * math.sqrt(1 / (1 + slope * slope))
xwr = x1 - (d - r) * math.sqrt(1 / (1 + slope * slope))
yw = y1 + (d - r) * slope * math.sqrt(1 / (1 + slope * slope))
ywr = y1 - (d - r) * slope * math.sqrt(1 / (1 + slope * slope))
c = 1e-08
if abs(x - xw) <= c and abs(y - yw) <= c:
	print(x, y, r)
elif abs(x - xwr) <= c and abs(y - ywr) <= c:
	print(x, y, r)
elif abs(xr - xw) <= c and abs(yr - yw) <= c:
	print(xr, yr, r)
elif abs(xr - xwr) <= c and abs(yr - ywr) <= c:
	print(xr, yr, r)


import math
(i, x1, y1, x2, y2) = input().split()
R = int(i)
x = int(x1)
y = int(y1)
xx = int(x2)
yy = int(y2)
a = (x - xx) * (x - xx)
b = (y - yy) * (y - yy)
d = math.sqrt(a + b)
flag = 0
if a + b >= R * R:
	print(x, end=' ')
	print(y, end=' ')
	print(R)
	flag = 1
elif flag != 1 and d != 0:
	r = (d + R) / 2
	t = xx + r * (x - xx) / d
	u = yy + r * (y - yy) / d
	print(t, end=' ')
	print(u, end=' ')
	print(r)
if d == 0:
	r = R / 2
	s = x - r
	v = y
	print(s, end=' ')
	print(v, end=' ')
	print(r)


from math import *
(R, x1, y1, x2, y2) = map(int, input().split())
if sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) < R:
	r = (R + sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)) / 2
	n = r
	m = r - sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	if m - n == 0:
		print(x1 + r, y1, r)
	else:
		xap = (m * x2 - n * x1) / (m - n)
		yap = (m * y2 - n * y1) / (m - n)
		print(xap, yap, r)
else:
	print(x1, y1, R)