Amr loves Geometry. One day he came up with a very interesting problem.

Amr has a circle of radius r and center in point (x, y). He wants the circle center to be in new position (x', y').

In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin by any angle and finally remove the pin.

Help Amr to achieve his goal in minimum number of steps.


-----Input-----

Input consists of 5 space-separated integers r, x, y, x' y' (1 ≤ r ≤ 10^5,  - 10^5 ≤ x, y, x', y' ≤ 10^5), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively.


-----Output-----

Output a single integer — minimum number of steps required to move the center of the circle to the destination point.


-----Examples-----
Input
2 0 0 0 4

Output
1

Input
1 1 1 4 4

Output
3

Input
4 5 6 5 6

Output
0



-----Note-----

In the first sample test the optimal way is to put a pin at point (0, 2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter).

[Image]

Difficulty: MEDIUM
Tags: Geometry

Mathematics

Starter code:

Solutions:
import math
(r, x, y, p, q) = list(map(int, input().strip().split(' ')))
print(math.ceil(((p - x) ** 2 + (q - y) ** 2) ** 0.5 / (2 * r)))


import math
(r, x, y, a, b) = map(int, input().split())
d = math.sqrt((a - x) ** 2 + (b - y) ** 2)
print(math.ceil(d / (2 * r)))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
PI = math.acos(-1.0)
d = math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))
t = d / (2 * r)
if t > math.floor(t):
	print(int(math.floor(t)) + 1)
else:
	print(int(t))


import math
(r, x, y, x1, y1) = map(int, input().split())
print(math.ceil(math.ceil(math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1))) / (2 * r)))


from math import *
a = [int(x) for x in input().split()]
r = a[0]
x1 = a[1]
y1 = a[2]
x2 = a[3]
y2 = a[4]
x = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if x1 == x2 and y1 == y2:
	print(0)
elif x < 2 * r:
	print(1)
else:
	ans = ceil((x - 2 * r) / (2 * r))
	print(ans + 1)


(r, x, y, x1, y1) = map(int, input().split())
dist = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
if dist == 0:
	print(int(dist))
elif dist < 2 * r:
	print(int(1))
elif dist % (2 * r) == 0:
	print(int(dist // (2 * r)))
else:
	print(int(dist // (2 * r) + 1))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
u = abs(x2 - x1)
v = abs(y2 - y1)
l = math.ceil(math.sqrt(u * u + v * v))
print(math.ceil(l / (2 * r)))


from math import ceil as c
(r, x, y, x2, y2) = map(int, input().split())
d = ((x2 - x) ** 2 + (y2 - y) ** 2) ** 0.5
print(c(d / (2 * r)))


from math import *
(r, x, y, x_, y_) = map(int, input().split())
d = sqrt((x - x_) ** 2 + (y - y_) ** 2)
print(ceil(d / (2 * r)))


import math
(r, x, y, x1, y1) = [int(i) for i in input().split()]
diffx = (x1 - x) * (x1 - x)
diffy = (y1 - y) * (y1 - y)
dist = math.sqrt(diffx + diffy)
print(math.ceil(dist / (2 * r)))


import os
import sys
from io import BytesIO, IOBase
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')

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2
from math import *
for _ in range(1):
	(r, x, y, x1, y1) = map(int, input().split())
	dist = sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
	print(ceil(dist / (2 * r)))


import math
arr = list(map(int, input().split()))
print(math.ceil(math.sqrt((arr[3] - arr[1]) * (arr[3] - arr[1]) + (arr[4] - arr[2]) * (arr[4] - arr[2])) / (2 * arr[0])))


import math

def distance(x1, y1, x2, y2):
	return math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) * 1.0)
inp = list(map(int, input().split()))
(r, x1, y1, x2, y2) = (inp[0], inp[1], inp[2], inp[3], inp[4])
dist = distance(x1, y1, x2, y2)
final = math.ceil(dist / (2 * r))
print(final)


import math
line = input().split()
r = int(line[0])
x0 = int(line[1])
y0 = int(line[2])
x1 = int(line[3])
y1 = int(line[4])
while True:
	if x0 == x1 and y0 == y1:
		print('0')
		break
	dist = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** (1 / 2)
	print(str(math.ceil(dist / (2 * r))))
	break


import math
(r, x, y, xx, yy) = [int(i) for i in input().split()]
dis = math.sqrt(abs(xx - x) * abs(xx - x) + abs(yy - y) * abs(yy - y))
ans = int(dis / 2 / r)
if ans < dis / 2 / r:
	ans += 1
print(ans)


import math
(r, x, y, xp, yp) = list(map(int, input().split()))
d = math.sqrt((x - xp) ** 2 + (y - yp) ** 2)
res = int(math.ceil(d / 2 / r))
print(res)


from sys import stdin, setrecursionlimit
from collections import deque
import math
input = stdin.readline
setrecursionlimit(int(200000.0))

def getstr():
	return input()[:-1]

def getint():
	return int(input())

def getints():
	return list(map(int, input().split()))

def getint1():
	return list(map(lambda x: int(x) - 1, input().split()))
jn = lambda x, l: x.join(map(str, l))
MOD = 10 ** 9 + 7
(y, n) = ('YES', 'NO')

def solve():
	(r, x1, y1, x2, y2) = getints()
	d = 2 * r
	dis = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
	print(-int(-dis // d))
solve()


def list_from_input():
	return list(map(int, input().split()))
import math

def main():
	(r, x, y, x_, y_) = list_from_input()
	distance = ((x - x_) ** 2 + (y - y_) ** 2) ** 0.5
	print(math.ceil(distance / (2 * r)))
main()


(r, x, y, x1, y1) = map(int, input().split())
from math import sqrt, ceil
d = float(sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)))
print(int(ceil(d / (2 * r))))


import sys
import math

def fn(r, x, y, x1, y1):
	d = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	if d % (2 * r) == 0:
		out = int(d / 2 / r)
	else:
		out = int(d / 2 / r) + 1
	return out
input = sys.stdin.read()
data = list(map(int, input.split()))
r = data[0]
x = data[1]
y = data[2]
x1 = data[3]
y1 = data[4]
print(fn(r, x, y, x1, y1))


(r, x1, y1, x2, y2) = map(int, input().split())
(d, m) = divmod((abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2) ** 0.5, 2 * r)
print(int(d) + int(m != 0))


l = list(map(int, input().split()))
r = l[0]
x1 = l[1]
y1 = l[2]
x2 = l[3]
y2 = l[4]
res = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
if res != 0 and res % int(res) != 0:
	res = int(res) + 1
c = res // (r * 2)
if res % (r * 2) != 0:
	c += 1
print(int(c))


from math import *

def euclid(x1, y1, x2, y2):
	x = x2 - x1
	y = y2 - y1
	return sqrt(x * x + y * y)
(r, x1, y1, x2, y2) = map(int, input().split())
print(ceil(euclid(x1, y1, x2, y2) / (2 * r)))


import math
(r, x, y, x1, y1) = map(int, input().split())
d = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(math.ceil(d / (2 * r)))


from math import sqrt
(r, x1, y1, x2, y2) = input().split()
(r, x1, y1, x2, y2) = map(int, [r, x1, y1, x2, y2])
d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
if d / (2 * r) == int(d / (2 * r)):
	s = int(d / (2 * r))
	print(s)
else:
	s = int(d / (2 * r))
	print(s + 1)


from math import hypot
(r, x, y, xn, yn) = map(int, input().split())
d = hypot(x - xn, y - yn)
ans = 0
if d == r or d == 0:
	print(0)
elif d < r:
	print(1)
else:
	mama = 0
	while mama < d:
		mama += 2 * r
		ans += 1
	print(ans)


import math
(r, x1, y1, x2, y2) = map(int, input().strip().split(' '))
if x1 == x2 and y1 == y2:
	print(0)
else:
	print(math.ceil(math.sqrt(pow(y2 - y1, 2) + pow(x2 - x1, 2)) / r / 2))


import math
(r, x, y, X, Y) = map(int, input().split())
d = math.sqrt(math.pow(X - x, 2) + math.pow(Y - y, 2))
print(int(math.ceil(d / (2 * r))))


(r, x, y, x1, y1) = map(int, input().split())
r *= 2
d = (x - x1) * (x - x1) + (y - y1) * (y - y1)
d = d ** (1 / 2)
print(int(d // r) + (1 if d % r else 0))


import math
__author__ = 'artyom'
(r, x, y, x0, y0) = map(int, input().split())
print(math.ceil(math.sqrt((x - x0) ** 2 + (y - y0) ** 2) / (2 * r)))


from math import *
(r, x, y, x1, y1) = map(int, input().split())
print(ceil(hypot(x1 - x, y1 - y) / 2 / r))


(r, x, y, x1, y1) = map(int, input().split())
p = (abs(x1 - x) ** 2 + abs(y1 - y) ** 2) ** 0.5
if p % (2 * r) != 0:
	print(int(p // (2 * r) + 1))
else:
	print(int(p // (2 * r)))


from math import sqrt
(r, x, y, a, b) = map(int, input().split())
dist = sqrt((x - a) ** 2 + (y - b) ** 2)
if dist == 0:
	print(0)
elif divmod(dist, 2 * r)[1] > 0 and dist > 0:
	print(int(divmod(dist, 2 * r)[0]) + 1)
else:
	print(int(divmod(dist, 2 * r)[0]))


(r, x, y, x1, y1) = map(int, input().split())
h = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(int(h // (r * 2)) + (h % (r * 2) != 0))


import math

def sqr(x):
	return x * x
(r, x1, y1, x2, y2) = input().split()
d = math.sqrt(sqr(int(x1) - int(x2)) + sqr(int(y1) - int(y2)))
print(math.ceil(d / (2 * int(r))))


import sys
input = sys.stdin.readline
(r, x, y, x1, y1) = map(int, input().split())
dist = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
res = int(dist / (2 * r))
if dist % (2 * r) > 0:
	res += 1
print(res)


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


from math import ceil
(r, x1, y1, x2, y2) = map(int, input().split())
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1 / 2)
print(ceil(d / (2 * r)))


(r, x, y, n_x, n_y) = map(int, input().split())
d = 2 * r
dis = (x - n_x) ** 2 + (y - n_y) ** 2
ans = pow(dis / d ** 2, 0.5)
if ans ** 2 == int(ans) ** 2 + 0.0:
	print(int(ans))
else:
	print(int(ans) + 1)


import math
str1 = list(map(int, input().split()))
r = str1[0]
x = str1[1]
y = str1[2]
x1 = str1[3]
y1 = str1[4]
d = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
print(math.ceil(d / (2 * r)))


(a, b, c, d, e) = map(int, input().split())
dis = (e - c) ** 2 + (d - b) ** 2
dis = dis ** 0.5
print(int(dis // (2 * a)) if dis % (2 * a) == 0 else int(dis // (2 * a)) + 1)


import math
(r, x, y, xp, yp) = map(int, input().split())
print((math.ceil(math.sqrt((xp - x) * (xp - x) + (yp - y) * (yp - y))) + 2 * r - 1) // (2 * r))


s = input()
a = s.split(' ')
r = int(a[0])
x = int(a[1])
y = int(a[2])
x1 = int(a[3])
y1 = int(a[4])
dist = pow((x - x1) * (x - x1) + (y - y1) * (y - y1), 0.5)
if dist == 0.0:
	print(0)
else:
	z = dist / (2 * r)
	if z - int(z) == 0.0:
		print(int(z))
	else:
		print(int(z + 1))


(r, x, y, X, Y) = map(int, input().split())
import math
s = (abs(X - x) ** 2 + abs(Y - y) ** 2) ** 0.5
s = s / (2 * r)
print(math.ceil(s))


(r, x, y, x2, y2) = [int(i) for i in input().split()]
x = abs(x - x2)
y = abs(y - y2)
n = 0
while (2 * r * n) ** 2 < x * x + y * y:
	n += 1
print(n)


import math
(r, x, y, x1, y1) = [int(x) for x in input().split(' ')]
a = (x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)
m = math.sqrt(abs(a)) / (2 * r)
print(math.ceil(m))


import sys
from collections import *
from heapq import *
import math
import bisect
(r, x, y, x1, y1) = map(int, input().split())
dis = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
print(math.ceil(dis / (2 * r)))


P = list(map(int, input().split()))

def output(r, x, y, X, Y):
	dist = ((X - x) ** 2 + (Y - y) ** 2) ** 0.5
	if dist % (2 * r) == 0:
		return dist // (2 * r)
	return dist // (2 * r) + 1
print(int(output(P[0], P[1], P[2], P[3], P[4])))


import sys
input = sys.stdin.readline
from math import log2, log, ceil

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	while x != link[x]:
		x = link[x]
	return x

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
(r, x, y, xx, yy) = int_array()
d = ((xx - x) ** 2 + (yy - y) ** 2) ** 0.5
ans = int(ceil(d / (2 * r)))
print(ans)


from math import sqrt
(r, x, y, x1, y1) = (int(x) for x in input().split())
dx = x - x1
dy = y - y1
n = sqrt(dx * dx + dy * dy) / r / 2.0
print(int(n - 1e-11 + 1))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
dis = (x1 - x2) ** 2 + (y1 - y2) ** 2
d = math.sqrt(dis)
res = d / (r * 2)
print(math.ceil(res))


import math
g = input()
(r, x, y, X, Y) = [int(x) for x in g.split()]
d = math.sqrt((X - x) ** 2 + (Y - y) ** 2)
l = 1
if d == 0:
	print('0')
elif 2 * r >= d:
	print('1')
else:
	while 2 * r < d:
		l += 1
		d = d - 2 * r
	print(l)


import math
(r, x, y, a, b) = map(int, input().split())
d = (a - x) * (a - x) + (b - y) * (b - y)
sd = d
d = pow(d, 0.5)
di = int(d)
Q = False
if di * di == sd:
	Q = True
else:
	di = di + 1
	if di * di == sd:
		Q = True
	else:
		di = di - 2
		if di * di == sd:
			Q = True
if Q:
	f = 0
	if di % (2 * r) != 0:
		f = 1
	print(di // (2 * r) + f)
else:
	di = math.floor(d)
	print(di // (2 * r) + 1)


import math
(r, x1, y1, x2, y2) = tuple(map(int, input().split(' ')))
d = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2))
ans = math.ceil(d / (2 * r))
print(ans)


import math
(r, x1, y1, x2, y2) = list(map(int, input().split()))
print(math.ceil(math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) / (2 * r)))


(r, x, y, x1, y1) = map(int, input().split())
dist = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
answer = 0
while dist > 0:
	dist -= 2 * r
	answer += 1
print(answer)


from math import sqrt, ceil
(r, x, y, x_, y_) = map(int, input().split())
ll = x_ - x
rr = y_ - y
re = sqrt(ll ** 2 + rr ** 2)
ma = 2 * r
print(ceil(re / ma))


import math
ans = 0
(r, x, y, x1, y1) = map(int, input().split())
d = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
ans = math.ceil(d / (r * 2))
print(ans)


from math import sqrt
(r, x, y, x_line, y_line) = map(int, input().split())
movement = 2 * r
distance = (x - x_line) ** 2 + (y - y_line) ** 2
distance = sqrt(distance)
ans = distance / movement
if ans % 1 > 0:
	ans = ans / 1
	ans += 1
print(int(ans))


def dis(x, x1, y, y1):
	return ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
import math
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y == y1:
	print(0)
else:
	steps = 0
	distance = dis(x, x1, y, y1)
	cos = abs(x - x1) / distance
	sin = abs(y - y1) / distance
	while distance > 2 * r:
		if x < x1:
			x = x + 2 * r * cos
		else:
			x = x - 2 * r * cos
		if y < y1:
			y = y + 2 * r * sin
		else:
			y = y - 2 * r * sin
		steps += 1
		distance = dis(x, x1, y, y1)
	print(steps + 1)


from math import sqrt
from math import ceil
entrada = input()
entrada_int = list(map(int, entrada.split(' ')))
vetor = entrada_int
raio = vetor[0]
a = vetor[1]
b = vetor[2]
c = vetor[3]
d = vetor[4]
x = sqrt((a - c) ** 2 + (b - d) ** 2)
resposta = x / (raio * 2)
print(ceil(resposta))


import math
s = input().split(' ')
s = [int(i) for i in s]
r = s[0]
x = s[1]
y = s[2]
x2 = s[3]
y2 = s[4]
d = 2 * r
t = math.sqrt((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
t1 = t / d
if t1 != int(t1):
	t1 = int(t1) + 1
else:
	t1 = int(t1)
print(t1)


def distance(x, y, x1, y1):
	m = (x - x1) ** 2 + (y - y1) ** 2
	return m ** 0.5

def moves(r, x, y, x1, y1):
	d = distance(x, y, x1, y1)
	m = d / (2 * r)
	if m == int(m):
		return int(m)
	else:
		return int(m) + 1
(r, x, y, x1, y1) = map(int, input().split())
print(moves(r, x, y, x1, y1))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())

def dist(x, y, c, d):
	return mt.sqrt((x - c) ** 2 + (y - d) ** 2)

def circle(x1, y1, x2, y2, r1, r2):
	distSq = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	if distSq + r2 <= r1:
		return True
	else:
		return False
(r, a, b, x, y) = M()
print(mt.ceil(dist(a, b, x, y) / (2 * r)))


from math import sqrt
(n, x, y, xi, yi) = map(int, input().split())
r = sqrt((xi - x) ** 2 + (y - yi) ** 2)
r = r / (2 * n)
if r == int(r):
	print(int(r))
else:
	print(int(r + 1))


import math
(r, x, y, x1, y1) = map(int, input().split())
r = r * 2
k = math.sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y))
if k == k // 1 and k // 1 % r == 0:
	print(int(k // r))
else:
	print(int(k // r + 1))


import math
(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
distance = math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
print(math.ceil(distance / (2 * r)))


from math import floor, ceil, sqrt

def distance(p1, p2):
	return sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
(r, x, y, a, b) = list(map(int, input().split()))
r *= 2
print(ceil(distance((x, y), (a, b)) / r))


from math import ceil

def main():
	(r, x1, y1, x2, y2) = map(float, input().split())
	x = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	print(ceil(x / (2 * r)))
main()


from math import ceil
(r, x, y, t1, t2) = [int(x) for x in input().split()]
x = abs(x - t1)
y = abs(y - t2)
print(ceil((x ** 2 + y ** 2) ** 0.5 / (r * 2)))


from math import hypot, ceil

def main():
	(r, x, y, x1, y1) = map(int, input().split())
	x -= x1
	y -= y1
	w = hypot(x, y)
	print(int(ceil(w * 0.5 / r)))
main()


import math
(r, xa, ya, xb, yb) = [int(x) for x in input().split()]
print(int(math.ceil(math.sqrt((xb - xa) ** 2 + (yb - ya) ** 2) / (2 * r))))


from math import sqrt
yo = list(map(int, input().split()))
r = yo[0]
x = yo[1]
y = yo[2]
xx = yo[3]
yy = yo[4]
dist = sqrt((x - xx) ** 2 + (y - yy) ** 2)
di = int(dist // (r * 2))
if dist == 0:
	print(0)
elif dist < r:
	print(1)
elif dist % (2 * r) == 0:
	print(di)
else:
	print(di + 1)


import math
(r, x, y, x1, y1) = map(int, input().split())
dia = 2 * r
dist = math.sqrt((x1 - x) ** 2 + (y - y1) ** 2)
if dist == 0:
	print(0)
else:
	ans = 0
	ans += dist // dia
	if dist % dia != 0:
		ans += 1
	print(int(ans))


from math import ceil
from math import sqrt

def mag(x, y):
	return sqrt(x * x + y * y)
inp = input().split()
dist = mag(int(inp[1]) - int(inp[3]), int(inp[2]) - int(inp[4]))
print(ceil(dist / (2 * int(inp[0]))))


def amr(r, x1, y1, x2, y2):
	x = x1 - x2
	y = y1 - y2
	dist = (x ** 2 + y ** 2) ** 0.5
	i = 0
	while dist > 0:
		dist -= 2 * r
		i += 1
	return i
a = list(map(int, input().split()))
print(amr(a[0], a[1], a[2], a[3], a[4]))


import math
inp = input().split(' ')
rad = int(inp[0])
x1 = int(inp[1])
y1 = int(inp[2])
x2 = int(inp[3])
y2 = int(inp[4])
x = (x1 - x2) ** 2
y = (y1 - y2) ** 2
leng = (x + y) ** 0.5
temp = leng - rad * 2
res = leng / (rad * 2)
print(math.ceil(res))


import math

def distance(x1, y1, x2, y2):
	return math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2))
(r, x, y, x1, y1) = map(int, input().split())
if x1 == x and y1 == y:
	print(0)
else:
	d = distance(x, y, x1, y1)
	print(math.ceil(d / (2 * r)))


from math import sqrt
__author__ = 'Konrad Strack'

def solve():
	(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
	d = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	steps = int(d // (2 * r))
	if steps * (2 * r) < d:
		steps += 1
	print(steps)

def __starting_point():
	solve()
__starting_point()


import math
(r, x, y, x_1, y_1) = map(int, input().split())
max = ((x_1 - x) ** 2 + (y_1 - y) ** 2) ** 0.5
print(int(math.ceil(max / (2 * r))))


import math
(r, x, y, xn, yn) = [int(x) for x in input().split()]
d = math.sqrt((x - xn) ** 2 + (y - yn) ** 2)
print(math.ceil(d / (2 * r)))


from math import *
(r, x, y, a, b) = map(int, input().split())
d = sqrt(pow(x - a, 2) + pow(y - b, 2))
ans = d / (2 * r)
if ans != int(ans):
	ans = ceil(ans)
print(int(ans))


(r, x, y, x1, y1) = map(int, input().split())
dis = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
if dis // (2 * r) == dis / (2 * r):
	print(int(dis // (2 * r)))
else:
	print(int(dis // (2 * r)) + 1)


from math import ceil
(r, x, y, x_n, y_n) = map(int, input().split())
d = ((x - x_n) ** 2 + (y - y_n) ** 2) ** 0.5
print(ceil(d / (2 * r)))


from math import ceil

def main():
	(r, x, y, x_g, y_g) = list(map(int, input().split()))
	distance = ((x - x_g) ** 2 + (y - y_g) ** 2) ** 0.5
	print(ceil(distance / (2 * r)))
main()


import math as m
(a, b, c, d, e) = map(int, input().split())
distance = m.sqrt((d - b) ** 2 + (e - c) ** 2)
print(m.ceil(distance / a / 2))


(r, a, b, c, d) = map(int, input().split())
from math import sqrt
q = sqrt(abs(c - a) ** 2 + abs(d - b) ** 2)
ans = q // (2 * r)
if q % (2 * r):
	ans += 1
print(int(ans))


import math
[r, x1, y1, x2, y2] = [int(i) for i in input().split()]
distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
print(math.ceil(distance / (2 * r)))


import math
from math import sqrt

def check(distance, radius):
	x = distance / (2 * radius)
	y = math.ceil(x)
	return y
(r, x, y, x_1, y_1) = map(int, input().split(' '))
distance = sqrt((x - x_1) ** 2 + (y - y_1) ** 2)
print(check(distance, r))


from math import sqrt, ceil

def dist(x, y, xx, yy):
	return sqrt((x - xx) ** 2 + (y - yy) ** 2)
[r, x, y, xx, yy] = [int(x) for x in input().split()]
print(ceil(dist(x, y, xx, yy) / (2 * r)))


import math
userInput = input()
userInput = userInput.split(' ')
userInput[0] = int(userInput[0])
userInput[1] = int(userInput[1])
userInput[2] = int(userInput[2])
userInput[3] = int(userInput[3])
userInput[4] = int(userInput[4])
radius = userInput[0]
oldx = userInput[1]
oldy = userInput[2]
newx = userInput[3]
newy = userInput[4]
distance = math.sqrt((newx - oldx) ** 2 + (newy - oldy) ** 2)
needed = math.ceil(distance / (2 * userInput[0]))
print(needed)


import math
string = input()
arr = string.split()
r = int(arr[0])
x = int(arr[1])
y = int(arr[2])
_x = int(arr[3])
_y = int(arr[4])
deltaX = math.fabs(x - _x)
deltaY = math.fabs(y - _y)
steps = math.ceil(math.sqrt(deltaX * deltaX + deltaY * deltaY) / (2 * r))
print(steps)


import math
entrada = input()
entrada = entrada.split(' ')
print(math.ceil(math.sqrt(pow(abs(int(entrada[1]) - int(entrada[3])), 2) + pow(abs(int(entrada[2]) - int(entrada[4])), 2)) / (int(entrada[0]) * 2)))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
x = d / r
y = math.ceil(x / 2)
print(y)


from math import *
(r, x, y, xp, yp) = list(map(int, input().split()))
print(ceil(sqrt((xp - x) * (xp - x) + (yp - y) * (yp - y)) / (2 * r)))


(r, x, y, x1, y1) = list(map(int, input().split()))
d = ((x - x1) ** 2 + (y - y1) ** 2) ** (1 / 2)
steps = d // (2 * r)
if d % (2 * r) != 0:
	steps += 1
print(int(steps))


from math import sqrt, ceil
(r, x, y, x1, y1) = list(map(int, input().split()))
r1 = sqrt((x - x1) ** 2 + (y - y1) ** 2)
y = 2 * r
print(ceil(r1 / y))


from math import hypot, ceil
(r, x, y, x2, y2) = [int(i) for i in input().split()]
x = abs(x - x2)
y = abs(y - y2)
print(ceil(hypot(x, y) / (2 * r)))


(r, x, y, x1, y1) = map(int, input().split())
distance = ((x1 - x) ** 2 + (y1 - y) ** 2) ** (1 / 2)
if distance == 0:
	print('0')
elif distance % (2 * r) == 0:
	print(int(distance / (2 * r)))
else:
	print(int(distance / (2 * r)) + 1)


import sys
inf = float('inf')
from math import ceil, floor, log, log2, sqrt, factorial, pow, pi, gcd

def powerMod(x, y):
	res = 1
	while y > 0:
		if y & 1:
			res = res * x
		y = y >> 1
		x = x * x
	return res
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(r, x1, y1, x2, y2) = get_ints()
dist = sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
print(ceil(dist / (2 * r)))


import math
(r, x, y, x1, y1) = map(int, input().split())
dx = abs(x1 - x)
dy = abs(y1 - y)
d = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
if x == x1 and y == y1:
	print(0)
else:
	print(math.ceil(d / (2 * r)))


from math import sqrt, ceil
(r, x, y, xd, yd) = map(int, input().split())
dx = abs(x - xd)
dy = abs(y - yd)
print(ceil(sqrt(dx ** 2 + dy ** 2) / (2 * r)))


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi
from bisect import bisect_left

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

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

def sti():
	return str(input())

def par(a):
	print(' '.join(list(map(str, a))))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

def sts(s):
	s = list(s)
	s.sort()
	return ''.join(s)

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)
(r, x1, y1, x2, y2) = isp()
d = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(ceil(d / (2 * r)))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(r, x1, y1, x2, y2) = LI()
	k = (pow(x1 - x2, 2) + pow(y1 - y2, 2)) ** 0.5
	r *= 2
	return int((k + r - eps) // r)
print(main())


import math
l = list(map(int, input().split()))
d = ((l[1] - l[3]) ** 2 + (l[2] - l[4]) ** 2) ** (1 / 2)
print(math.ceil(d / (2 * l[0])))


import math

def dist(x1, y1, x2, y2):
	a = (x1 - x2) ** 2
	b = (y1 - y2) ** 2
	c = math.sqrt(a + b)
	return c
(r, x, y, x2, y2) = map(int, input().split())
distance = dist(x, y, x2, y2)
print(math.ceil(distance / (2 * r)))


(r, x, y, xx, yy) = map(int, input().split())
l = ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5
print(-int(-l // (2 * r)))


import os
import sys
from io import BytesIO, IOBase
from math import sqrt, ceil

def solution(args):
	(r, x, y, x1, y1) = args
	dist = sqrt((x - x1) ** 2 + (y - y1) ** 2)
	if dist == 0:
		write(0)
	elif dist <= 2 * r:
		write(1)
	else:
		write(ceil(dist / (2 * r)))

def main():
	solution(r_array())
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args[:-1]:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(str(args[-1]))
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())
main()


import math
(r, x1, y1, x2, y2) = [int(var) for var in input().split()]
d = math.sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))
s = d / r / 2
print(math.ceil(s))


from sys import stdin
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
from math import sqrt, ceil
(r, x, y, x1, y2) = mp()
d = sqrt((x1 - x) ** 2 + (y2 - y) ** 2)
print(ceil(d / (2 * r)))


from math import ceil, hypot
(r, x, y, xx, yy) = map(float, input().split())
print(ceil(hypot(xx - x, yy - y) / 2 / r))


import math
inp = list(map(int, input().split()))
rad = inp[0]
(c1, c2) = ([inp[1], inp[2]], [inp[3], inp[4]])
sqr = math.ceil(math.sqrt((c1[0] - c2[0]) ** 2 + (c1[1] - c2[1]) ** 2) / (2 * rad))
print(sqr)


import math as m
(r, x, y, x_, y_) = [int(i) for i in input().split()]
d = m.sqrt((x_ - x) ** 2 + (y_ - y) ** 2)
print(m.ceil(d / (2 * r)))


from math import ceil, sqrt, acos, pow
(r, x1, y1, x2, y2) = map(int, input().split())
PI = acos(-1.0)
d = sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2))
print(ceil(d / (2 * r)))


from math import sqrt, ceil
s = input().split(' ')
s = map(int, s)
s = list(s)
r = s[0]
x = s[1]
y = s[2]
x1 = s[3]
y1 = s[4]
del s
dist = sqrt((x - x1) ** 2 + (y - y1) ** 2)
d = 2 * r
resp = ceil(dist / d)
print(resp)


from functools import reduce
import os
import sys
from collections import *
from math import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def arr():
	return [int(i) for i in input().split()]

def sarr():
	return [int(i) for i in input()]

def starr():
	return [str(x) for x in input().split()]

def inn():
	return int(input())

def svalue():
	return tuple(map(str, input().split()))

def parr():
	return [value() for i in range(n)]
mo = 1000000007
inf = 1e+18
div = 998244353
(r, x, y, x1, y1) = value()
res = sqrt((x - x1) ** 2 + (y - y1) ** 2)
print(ceil(res / (2 * r)))


import math
(x, a, b, c, d) = map(int, input().split())
e = math.sqrt((d - b) ** 2 + (c - a) ** 2)
print(math.ceil(e / (2 * x)))


read = lambda : map(int, input().split())
(r, x1, y1, x2, y2) = read()
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
ans = int(s // (r * 2)) + int(s % (r * 2) > 0)
print(ans)


import math

def get_int_vector():
	return [int(x) for x in input().split()]
(r, x0, y0, x, y) = get_int_vector()
dist = math.sqrt((x0 - x) ** 2 + (y0 - y) ** 2)
steps = int(dist // (2 * r))
if dist - steps * 2 * r > 0:
	steps += 1
print(steps)


w = list(map(int, input().split()))
e = ((w[1] - w[3]) ** 2 + (w[2] - w[4]) ** 2) ** (1 / 2)
r = e // w[0]
if e % (2 * w[0]) == 0:
	print(int(r // 2))
else:
	print(int(r // 2 + 1))


import math
ls = input().split(' ')
r = int(ls[0])
x1 = int(ls[1])
y1 = int(ls[2])
x2 = int(ls[3])
y2 = int(ls[4])
x_abs = abs(x1 - x2)
y_abs = abs(y1 - y2)
m = math.sqrt(x_abs * x_abs + y_abs * y_abs)
if m == 0:
	print(0)
elif m <= 2 * r:
	print(1)
else:
	print(math.ceil(m / (2 * r)))


import math

def dist(x, xx, y, yy):
	fix = (x - xx) ** 2 + (y - yy) ** 2
	fix = math.sqrt(fix)
	return fix
(r, x, y, xx, yy) = map(int, input().split())
ans = math.ceil(dist(x, xx, y, yy) / (2 * r))
print(ans)


import math
(r, x, y, x1, y1) = map(float, input().split())
distance = (x1 - x) ** 2 + (y1 - y) ** 2
distance **= 1 / 2
answer = math.ceil(distance / (2 * r))
print(answer)


import math
(r, x, y, a, b) = [int(i) for i in input().split(' ')]
dist = ((a - x) ** 2 + (b - y) ** 2) ** 0.5
r *= 2
if dist == 0:
	print(0)
else:
	print(math.ceil(dist / r))


import sys
import math
input = sys.stdin.readline
(r, x, y, x1, y1) = map(int, input().split())
dis = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
ans = math.floor(dis / (r * 2))
rem = dis % (r * 2)
if rem > 0:
	ans += 1
print(ans)


import sys
from math import ceil
input = sys.stdin.readline
(r, x1, y1, x2, y2) = map(int, input().split())
d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
ans = d
ans /= 2 * r
print(ceil(ans))


import math
arr = [int(x) for x in input().split()]
r = arr[0]
x1 = arr[1]
y1 = arr[2]
x2 = arr[3]
y2 = arr[4]
resp = math.sqrt(math.pow(y2 - y1, 2) + pow(x2 - x1, 2))
resp = math.ceil(resp / r / 2)
print(resp)


import math
(r, x, y, x1, y1) = [int(x) for x in input().split()]
distance = ((x - x1) * (x - x1) + (y - y1) * (y - y1)) ** 0.5
print(math.ceil(distance / (2 * r)))


import os
import sys
from io import BytesIO, IOBase
mod = 10 ** 9 + 7
from math import sqrt, ceil

def main():
	(r, x, y, a, b) = map(int, input().split())
	dist = sqrt((x - a) ** 2 + (y - b) ** 2)
	print(ceil(dist / (2 * r)))

def nouse0():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse1():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse2():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
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')

def nouse3():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse4():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse5():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
main()


(r, x1, y1, x2, y2) = (float(x) for x in input().split())
dest = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
if x1 == x2 and y1 == y2:
	print(0)
else:
	res = 0
	while dest > 0:
		dest -= 2 * r
		res += 1
	print(res)


import os, sys, time, collections, math, pprint, itertools as it, operator as op, bisect as bs, functools as fn
(maxx, localsys, mod) = (1 << 60, 0, int(1000000000.0 + 7))
nCr = lambda n, r: reduce(mul, range(n - r + 1, n + 1), 1) // factorial(r)
ceil = lambda n, x: (n + x - 1) // x
(osi, oso) = ('/home/priyanshu/Documents/cp/input.txt', '/home/priyanshu/Documents/cp/output.txt')
if os.path.exists(osi):
	sys.stdin = open(osi, 'r')
	sys.stdout = open(oso, 'w')
input = sys.stdin.readline
from functools import reduce

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

def Kth_beautiful_string():
	for _ in range(int(input())):
		(n, k) = maps()
		arr = ['a'] * n
		for i in range(n - 1, -1, -1):
			if n - i - 1 >= k:
				arr[i] = arr[i + (n - i - 1) - (k - 1)] = 'b'
				print(''.join(arr))
				break
			k -= n - i - 1
(r, x1, y1, x2, y2) = maps()
dis = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
x = math.ceil(math.ceil(dis) / (2 * r))
print(x)


from math import *

def calc(x1, y1, x2, y2):
	dist = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	return dist
(r, x, y, a, b) = map(int, input().split())
z = calc(x, y, a, b)
if z % (2 * r) > 0:
	print(int(z // (2 * r) + 1))
else:
	print(int(z // (2 * r)))


from math import ceil

def dist(a, b):
	return (a * a + b * b) ** 0.5

def how_many(r, sx, sy, tx, ty):
	l = dist(sx - tx, sy - ty)
	res = l / (2 * r)
	return ceil(res)
(r, sx, sy, tx, ty) = map(int, input().split())
print(how_many(r, sx, sy, tx, ty))


import math

def pin(r, x, y, x_, y_):
	l = math.sqrt((x_ - x) ** 2 + (y_ - y) ** 2)
	a = (l - 2 * r) / (2 * r)
	if a == int(a):
		return int(a + 1)
	else:
		return int(a + 2)

def main():
	il = input().split()
	print(pin(float(il[0]), float(il[1]), float(il[2]), float(il[3]), float(il[4])))
main()


import math
(r, x, y, c, d) = [int(x) for x in input().split()]
dist = math.sqrt((c - x) ** 2 + (d - y) ** 2)
steps = dist / (r + r)
print(math.ceil(steps))


import math
[r, x, y, x1, y1] = list(map(int, input().split()))
d = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
if d == 0:
	print(0)
else:
	e = d / (2 * r)
	print(math.ceil(e))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
x = distance / (2 * r)
print(int(math.ceil(x)))


l = list(map(int, input().split()))
d = ((l[1] - l[3]) ** 2 + (l[2] - l[4]) ** 2) ** (1 / 2)
print(-int(-d // (l[0] * 2)))


import math
(r, x, y, x2, y2) = (int(x) for x in input().split())
razdalja = math.sqrt((x2 - x) ** 2 + (y2 - y) ** 2)
if razdalja % (2 * r) != 0:
	print(int(razdalja // (2 * r)) + 1)
else:
	print(int(razdalja / (2 * r)))


import math
a = list(map(int, input().strip().split(' ')))
r = a[0]
x1 = a[1]
y1 = a[2]
x2 = a[3]
y2 = a[4]
d = (x2 - x1) ** 2 + (y1 - y2) ** 2
s = d * 1.0
s = math.sqrt(s)
s = s / (2 * r)
c = int(s)
if c == s:
	print(c)
else:
	c = c + 1
	print(c)


import os
import math
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
test_count = 1
if debug:
	test_count = inp()
for t in range(test_count):
	if debug:
		print('Test Case #', t + 1)
	(r, x1, y1, x2, y2) = invr()
	dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	print(math.ceil(dist / (2 * r)))


import atexit
import io
import sys
import math as m
R = lambda : map(int, input().split())
(r, x, y, x1, y1) = R()
ans = m.ceil(m.sqrt((x - x1) ** 2 + (y - y1) ** 2) / (2 * r))
print(ans)


(r, x, y, z, w) = [int(r) for r in input().split()]

def steps(r, x, y, z, w):
	diameter = 2 * r
	d = pow((x - z) ** 2 + (y - w) ** 2, 0.5)
	if d % diameter == 0:
		stepreq = d // diameter
	else:
		stepreq = 1 + d // diameter
	print(int(stepreq))
steps(r, x, y, z, w)


from math import *
(r, x1, y1, x2, y2) = [int(_) for _ in input().split()]
print(ceil(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 / (2 * r)))


from math import *
(r, x, y, nx, ny) = list(map(int, input().split(' ')))
r *= 2
diff = (x - nx) * (x - nx) + (y - ny) * (y - ny)
diff = sqrt(diff)
print(ceil(diff / r))


import math

def minSteps(r, x, y, newX, newY):
	distance = math.sqrt(pow(x - newX, 2) + pow(y - newY, 2))
	return math.ceil(distance / (2 * r))
(r, x, y, newX, newY) = [int(x) for x in input().split()]
print(minSteps(r, x, y, newX, newY))


from math import sqrt
from math import ceil
(r, x, y, x2, y2) = map(int, input().split())
print(ceil(sqrt((x - x2) ** 2 + (y - y2) ** 2) / (2 * r)))


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	(r, x, y, X, Y) = map(int, input().split())
	print(math.ceil(((X - x) ** 2 + (Y - y) ** 2) ** 0.5 / (2 * r)))
for _ in range(1):
	solve()


import math
(r, x0, y0, x1, y1) = str(input()).split()
print(math.ceil(math.sqrt((int(x1) - int(x0)) ** 2 + (int(y1) - int(y0)) ** 2) / (2 * int(r))))


(r, x1, y1, x2, y2) = map(int, input().split())
print(int(-(-((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 // (r * 2))))


import math
(r, x, y, x1, y1) = input().split()
steps = 0
x = int(x)
x1 = int(x1)
y = int(y)
y1 = int(y1)
r = int(r)
d = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
while 2 * r < d:
	steps = steps + 1
	d = d - 2 * r
if d != 0:
	print(steps + 1)
else:
	print('0')


import math
A = list(map(int, input().split()))
r = A[0]
x = A[1]
y = A[2]
x_prime = A[3]
y_prime = A[4]
if x == x_prime and y == y_prime:
	print(0)
else:
	distance = math.sqrt(pow(x - x_prime, 2) + pow(y - y_prime, 2))
	turns = distance / (2 * r)
	print(math.ceil(turns))


import math
(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
t = abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2
t = math.sqrt(t)
t = t / (2 * r)
if t % 1 == 0:
	print(int(t))
else:
	print(int(t) + 1)


import math
g = 0
(a, b, c, d, e) = [int(x) for x in input().split()]
dist = math.sqrt((d - b) ** 2 + (e - c) ** 2)
g = dist / (2 * a)
print(math.ceil(g))


(r, x, y, xf, yf) = list(map(int, input().split()))
from math import sqrt, ceil
distancia = sqrt((x - xf) ** 2 + (y - yf) ** 2)
print(int(ceil(distancia / (2 * r))))


from sys import stdin, stdout
from math import gcd, sqrt, ceil
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
(r, x, y, x1, y1) = iia()
d = sqrt(pow(x1 - x, 2) + pow(y1 - y, 2))
ans = ceil(d / (2 * r))
print(ans)


(r, x, y, a, b) = map(int, input().split())
dis = ((x - a) ** 2 + (y - b) ** 2) ** 0.5
print(-int(-dis // (2 * r)))


from math import sqrt
input = input().split(' ')
r = int(input[0])
(x, y) = (abs(int(input[3]) - int(input[1])), abs(int(input[4]) - int(input[2])))

def f():
	global x, y
	a = sqrt(x ** 2 + y ** 2)
	if a == 0:
		return 0
	if a < 2 * r:
		return 1
	else:
		n = a // (2 * r)
		if n * 2 * r == a:
			return n
		elif a - n * 2 * r < 2 * r:
			return n + 1
		else:
			return n + 2
print(int(f()))


import math
(r, x, y, xx, yy) = map(int, input().split())
d = math.sqrt((x - xx) * (x - xx) + (y - yy) * (y - yy))
print(math.ceil(d / (2 * r)))


(r, x, y, a, b) = list(map(int, input().split()))
import math
dist = math.ceil(math.sqrt((x - a) ** 2 + (y - b) ** 2) / (2 * r))
print(dist)


import math
(r, x, y, xd, yd) = map(int, input().split())
print((math.ceil(math.sqrt((xd - x) * (xd - x) + (yd - y) * (yd - y))) + 2 * r - 1) // (2 * r))


import math

def distance(x, y, x1, y1):
	return ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
a = list(map(int, input().split(' ')))
r = a[0]
(x, y) = (a[1], a[2])
(x1, y1) = (a[3], a[4])
dist = math.ceil(distance(x, y, x1, y1) / int(r * 2))
if dist == 0:
	print(0)
else:
	print(dist)


k = input()
a1 = int(k.split(' ')[0])
a2 = int(k.split(' ')[1])
a3 = int(k.split(' ')[2])
a4 = int(k.split(' ')[3])
a5 = int(k.split(' ')[4])
dist = ((a5 - a3) ** 2 + (a4 - a2) ** 2) ** 0.5
if dist % (2 * a1) == 0:
	print(int(dist // (2 * a1)))
else:
	print(int(dist // (2 * a1) + 1))


import math
(r, x, y, x1, y1) = list(map(int, input().split()))
dist = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(math.ceil(dist / (2 * r)))


import math

def distance(x1, y1, x2, y2):
	return math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) * 1.0)
(r, x, y, x1, y1) = map(int, input().split())
dis = distance(x, y, x1, y1)
print(math.ceil(dis / (2 * r)))


import math

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

def solve(r, x1, y1, x2, y2):
	x = calculateDistance(x1, y1, x2, y2)
	y = math.ceil(x / (2 * r))
	print(y)
(R, X1, Y1, X2, Y2) = [int(x) for x in input().split()]
solve(R, X1, Y1, X2, Y2)


import math
c = []
c = input().split()
r = int(c[0])
x = int(c[1])
y = int(c[2])
a = int(c[3])
b = int(c[4])
print(math.ceil(math.sqrt((x - a) * (x - a) + (y - b) * (y - b)) / (2 * r)))


(r, x, y, k, m) = map(int, input().split())
s = ((x - k) ** 2 + (y - m) ** 2) ** 0.5
if s == 0:
	print(0)
elif s <= r:
	print(1)
else:
	print(int(s // (2 * r)) + (s % (2 * r) > 0))


import math

def solve():
	(r, x0, y0, x1, y1) = [int(x) for x in input().split(' ')]
	return math.ceil(math.sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) / (2 * r))
print(solve())


import math
tmp = input().split()
r = int(tmp[0])
x1 = int(tmp[1])
y1 = int(tmp[2])
x2 = int(tmp[3])
y2 = int(tmp[4])
dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
q = int(dist / (2 * r))
if q * 2 * r != dist:
	q += 1
print(int(q))


import sys

def main():
	[r0, x0, y0, x1, y1] = list(map(int, sys.stdin.readline().split()))
	distance2 = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)
	r = 2 * r0
	n = int(distance2 ** 0.5 / r) + 1
	if (n * r) ** 2 == distance2:
		print(n)
		return
	if ((n - 1) * r) ** 2 == distance2:
		print(n - 1)
		return
	if ((n + 1) * r) ** 2 == distance2:
		print(n + 1)
		return
	print(n)
main()


import math
(r, x, y, a, b) = [int(i) for i in input().split(' ')]
d = (a - x) ** 2 + (b - y) ** 2
d = d ** 0.5
print(int(math.ceil(d / (2 * r))))


import math
(r, x, y, x_, y_) = map(int, input().split())
d = ((x - x_) ** 2 + (y - y_) ** 2) ** 0.5
print(math.ceil(d / (2 * r)))


from math import ceil, inf, sqrt
import sys

def pro(x, y, p, q, r):
	if (x, y) == (p, q):
		print(0)
		return
	dist = (x - p) ** 2 + (y - q) ** 2
	dist = sqrt(dist)
	ans = ceil(dist / (2 * r))
	print(ans)
t = 1
for i in range(t):
	(r, x, y, p, q) = list(map(int, input().split()))
	pro(x, y, p, q, r)


import math
l = list(map(int, input().split()))

def f(l):
	r = l[0]
	x = l[1]
	y = l[2]
	a = l[3]
	b = l[4]
	dist = math.sqrt((x - a) ** 2 + (y - b) ** 2)
	if dist == 0:
		return 0
	t = dist / (2 * r)
	if t % 1 == 0:
		return int(t)
	return int(t) + 1
print(f(l))


import math
(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
c1 = (x1, y1)
c2 = (x2, y2)

def distance(a, b):
	(xa, ya) = a
	(xb, yb) = b
	return math.sqrt((xa - xb) ** 2 + (ya - yb) ** 2)
d = distance(c1, c2)
full_length_steps = int(d // (2 * r))
if d - 2 * r * full_length_steps == 0:
	print(full_length_steps)
else:
	print(full_length_steps + 1)


import math
l = [int(x) for x in input().split()]
r = l[0]
(x, y) = (l[1], l[2])
(xc, yc) = (l[3], l[4])
if xc == x and yc == y:
	print(0)
else:
	dist = math.sqrt((xc - x) ** 2 + (yc - y) ** 2)
	dist = math.ceil(dist)
	ans = math.ceil(abs(dist) / (2 * r))
	print(ans)


values = list(map(int, input().split()))
distance = ((values[1] - values[3]) ** 2 + (values[2] - values[4]) ** 2) ** 0.5
if distance % (2 * values[0]) == 0:
	print(int(distance / (2 * values[0])))
else:
	print(int(distance / (2 * values[0])) + 1)


import math
cn = [int(i) for i in input().split()]
l = (math.fabs(cn[1] - cn[3]) ** 2 + math.fabs(cn[2] - cn[4]) ** 2) ** 0.5
ret = int(l // (cn[0] * 2) + int(bool(l % (cn[0] * 2))))
print(ret)


from math import ceil
(r, x1, y1, x2, y2) = map(int, input().split())
d = (abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2) ** 0.5
print(ceil(d / (2 * r)))


import math as m
(r, x, y, x1, y1) = map(int, input().split())
dist = m.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
if dist % (2 * r) == 0:
	print(int(dist // (2 * r)))
else:
	print(int(dist // (2 * r) + 1))


from math import sqrt as S
(r, x, y, X, Y) = map(int, input().split())
D = (x - X) * (x - X) + (y - Y) * (y - Y)
d = S(D)
r *= 2
k = d / r
j = int(k)
T = j * r
T = T * T
if T != D:
	j += 1
print(j)


import math
entrada = input().split()
r = int(entrada[0])
x1 = int(entrada[1])
y1 = int(entrada[2])
x2 = int(entrada[3])
y2 = int(entrada[4])
d = math.sqrt(pow(y2 - y1, 2) + pow(x2 - x1, 2))
print(math.ceil(d / r / 2))


from math import ceil

def main():
	(r, x0, y0, x1, y1) = map(int, input().split())
	d = ((x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1)) ** 0.5
	ans = ceil(d / 2 / r)
	print(ans)
main()


import math
(r, x, y, x1, y1) = map(int, input().split())
d = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
m = d / (2 * r)
if m == int(m):
	print(int(m))
else:
	print(int(int(m) + 1))


import math
L = list(map(int, input().split()))
d = ((L[1] - L[3]) ** 2 + (L[2] - L[4]) ** 2) ** 0.5
print(math.ceil(d / (2 * L[0])))


import math
b = list(input().split())
b = [int(i) for i in b]
a = math.sqrt((b[1] - b[3]) ** 2 + (b[2] - b[4]) ** 2)
if a % (2 * b[0]) == 0:
	print(int(a // (2 * b[0])))
else:
	print(int(a // (2 * b[0]) + 1))


import math
(r, x, y, xx, yy) = list(map(int, input().split()))
dist = ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5
print(math.ceil(dist / (r * 2)))


arr = list(map(int, input().split()))

def minDist(x1, y1, x2, y2):
	return pow(pow(x1 - x2, 2) + pow(y1 - y2, 2), 0.5)
dist = minDist(arr[1], arr[2], arr[3], arr[4])
result = dist / (2 * arr[0])
if result - int(result) == 0:
	print(int(result))
else:
	print(int(result) + 1)


from math import ceil

class Solution:

	def __init__(self):
		(self.r, self.x, self.y, self.x_, self.y_) = [int(x) for x in input().split()]

	def solve_and_print(self):
		print(ceil((abs(self.x_ - self.x) ** 2 + abs(self.y_ - self.y) ** 2) ** 0.5 / (self.r << 1)))
Solution().solve_and_print()


(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
counter = 0
while counter * 2 * r < d:
	counter += 1
print(counter)


from math import *
(r, x, y, x2, y2) = [int(a) for a in input().split()]
d = sqrt((x2 - x) ** 2 + (y2 - y) ** 2)
res = ceil(d / (2 * r))
print(res)


from math import *
x = [int(q) for q in input().split()]
r = x[0]
x1 = x[1]
y1 = x[2]
x2 = x[3]
y2 = x[4]
ans = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(ceil(ans / (2 * r)))


ar = []
for i in input().split(' '):
	ar.append(int(i))
r = ar[0] * 2
x1 = ar[1]
y1 = ar[2]
x2 = ar[3]
y2 = ar[4]
diff = pow((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2), 0.5)
count = diff // r
if diff % r != 0:
	count = count + 1
print(int(count))


import math
(r, x, y, x2, y2) = map(int, input().split())
dis = pow(pow(x - x2, 2) + pow(y - y2, 2), 0.5)
print(math.ceil(dis / (2 * r)))


def way_cut(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
(r, x, y, x1, y1) = map(int, input().split())
z = way_cut(x, y, x1, y1)
if z % (2 * r) == 0:
	print(int(z // (2 * r)))
else:
	print(int(z // (2 * r)) + 1)


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

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

def solve(r, x1, y1, x2, y2):
	dist = distance(x1, y1, x2, y2)
	return int(ceil(dist / (2 * r)))
(r, x1, y1, x2, y2) = list(map(int, stdin.readline().rstrip().split()))
stdout.write(str(solve(r, x1, y1, x2, y2)))


import sys
import math
from collections import Counter
from collections import OrderedDict
from collections import defaultdict
from functools import reduce
sys.setrecursionlimit(10 ** 6)

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

def printt(n):
	sys.stdout.write(str(n) + '\n')

def listt():
	return [int(i) for i in inputt().split()]

def gcd(a, b):
	return math.gcd(a, b)

def lcm(a, b):
	return a * b // gcd(a, b)

def factors(n):
	step = 2 if n % 2 else 1
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(math.sqrt(n)) + 1, step) if n % i == 0)))

def comb(n, k):
	factn = math.factorial(n)
	factk = math.factorial(k)
	fact = math.factorial(n - k)
	ans = factn // (factk * fact)
	return ans

def is_prime(n):
	if n <= 1:
		return False
	if n == 2:
		return True
	if n > 2 and n % 2 == 0:
		return False
	max_div = math.floor(math.sqrt(n))
	for i in range(3, 1 + max_div, 2):
		if n % i == 0:
			return False
	return True

def maxpower(n, x):
	B_max = int(math.log(n, x)) + 1
	return B_max
(r, x1, y1, x2, y2) = map(int, inputt().split())
d = 0
d = (x2 - x1) ** 2 + (y2 - y1) ** 2
d = d ** 0.5
print(math.ceil(d / (2 * r)))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
d = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
di = r * 2
resposta = int(math.ceil(d / di))
print(resposta)


import math
t = list(map(float, input().split()))
print(int(math.ceil((abs(t[3] - t[1]) ** 2 + abs(t[4] - t[2]) ** 2) ** (1 / 2) / t[0] / 2)))


(r, x1, y1, x2, y2) = [int(x) for x in input().split()]
distance = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
result = int(distance / (2 * r)) if distance / (2 * r) == int(distance / (2 * r)) else int(distance / (2 * r)) + 1
print(result)


import math
(r, x, y, X, Y) = map(int, input().split())
size = ((X - x) ** 2 + (Y - y) ** 2) ** 0.5
print(math.ceil(size / (2 * r)))


(r, n, m, x, y) = [int(x) for x in input().split()]
d = ((n - x) ** 2 + (y - m) ** 2) ** 0.5
if d % (2 * r):
	print(int(d // (2 * r) + 1))
else:
	print(int(d // (2 * r)))


from math import sqrt, ceil
(r, x, y, xx, yy) = map(int, input().split())
diff = sqrt((x - xx) ** 2 + (y - yy) ** 2)
print(ceil(ceil(diff) / (r * 2)))


(r, x, y, s, t) = map(int, input().split())
dist = ((x - s) ** 2 + (y - t) ** 2) ** 0.5
res = 0
while dist > 0:
	res += 1
	dist -= 2 * r
print(res)


import re
from sys import stderr
from typing import Union, Generator, List, Tuple
import string
EPS = 1e-10

def main():
	(rc, xc, yc, x, y) = map(int, input().split())
	distance = ((x - xc) ** 2 + (y - yc) ** 2) ** 0.5
	rc *= 2
	if distance % rc < EPS:
		res = distance // rc
	else:
		res = distance // rc + 1
	print(int(res))
main()


import math
(r, x, y, x1, y1) = list(map(int, input().rstrip().split()))
dist = math.sqrt(math.pow(x1 - x, 2) + math.pow(y1 - y, 2))
q = dist // (2 * r)
rem = dist % (2 * r)
count = q
if rem > 0:
	count += 1
print(int(count))


import sys
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y == y1:
	print(0)
	sys.exit(0)
dist = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
t = 0
while dist > r * 2:
	t = t + 1
	dist = dist - 2 * r
print(t + 1)


import math

def distance(x1, y1, x2, y2):
	return math.sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2))
(r, x, y, xd, yd) = map(int, input().split())
d = 2 * r
dist = distance(x, y, xd, yd)
print(math.ceil(dist / d))


import math
(r, x, y, x2, y2) = map(int, input().split())
dx = abs(x - x2)
dy = abs(y - y2)
dist = math.sqrt(dx ** 2 + dy ** 2)
print(math.ceil(dist / (2 * r)))


import sys, math
input = sys.stdin.readline
(r, x1, y1, x2, y2) = [int(c) for c in input().split()]
dX = abs(x2 - x1)
dY = abs(y2 - y1)
d = (dX ** 2 + dY ** 2) ** (1 / 2)
move = math.ceil(d / (2 * r))
print(move)


(r, x, y, x1, y1) = map(int, input().split())
import math
a = math.sqrt(abs(x - x1) ** 2 + abs(y - y1) ** 2)
b = math.ceil(a / r)
print(math.ceil(b / 2))


import math
(x, y, z, a, b) = map(int, input().split())
s = math.sqrt((a - y) * (a - y) + (b - z) * (b - z))
print(math.ceil(s / (2 * x)))


from math import sqrt, ceil
(r, x, y, x1, y1) = map(int, input().split())
dist = sqrt((x1 - x) ** 2 + (y1 - y) ** 2) / 2
moves = ceil(dist / r)
print(moves)


n = list(map(int, input().split(' ')))
rad = n[0]
sqdis = (n[1] - n[3]) ** 2 + (n[2] - n[4]) ** 2
tr = sqdis ** 0.5
k = tr / rad
if k == 0:
	print(0)
elif k % 2 == 0:
	print(int(k // 2))
else:
	print(int(k // 2 + 1))


import math
(r, x, y, x1, y1) = (int(i) for i in input().split())
d = math.sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y))
print(math.ceil(d / (2 * r)))


from math import sqrt, ceil
params = list(map(int, list(input().split())))
(r, x1, y1, x2, y2) = (params[0], params[1], params[2], params[3], params[4])
delta = sqrt(abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2)
print(ceil(delta / (2 * r)))


import math
(r, a, b, c, d) = map(int, input().split())
distance = (abs(c - a) ** 2 + abs(d - b) ** 2) ** 0.5
print(math.ceil(distance / (2 * r)))


from math import hypot, ceil
(r, x, y, x2, y2) = map(int, input().split())
d = hypot(x2 - x, y2 - y)
print(ceil(d / r / 2))


a = input().split()
r = int(a[0])
x = int(a[1])
y = int(a[2])
x1 = int(a[3])
y1 = int(a[4])
dst = ((x1 - x) ** 2 + (y - y1) ** 2) ** (1 / 2)
if dst == 0:
	print(0)
elif dst / (r * 2) == dst // (r * 2):
	print(int(dst // (r * 2)))
else:
	print(int(dst // (r * 2)) + 1)


import math as m
(r, x, y, x1, y1) = map(int, input().split())
a = m.sqrt((x - x1) ** 2 + (y - y1) ** 2)
a /= 2 * r
print(m.ceil(a))


(r, x1, y1, x2, y2) = map(int, input().split())
from math import *
dc = sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
if round(dc, 0) == dc and int(dc) % (2 * r) == 0:
	print(int(dc) // (2 * r))
else:
	print(floor(dc) // (2 * r) + 1)


import math
(r, x, y, x1, y1) = input().split()
r = float(r)
x = float(x)
y = float(y)
x1 = float(x1)
y1 = float(y1)
ans = math.ceil(((y1 - y) ** 2 + (x1 - x) ** 2) ** 0.5 / (2 * r))
print(ans)


import math
(r, x1, y1, x2, y2) = list(map(int, input().split()))
d2 = (x1 - x2) ** 2 + (y1 - y2) ** 2
print(int(math.sqrt(d2) + 2 * r - 1e-06) // (2 * r))


import math
(r, x1, y1, x2, y2) = list(map(int, input().split()))
dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
ans = 0
ans += dist / (r * 2)
print(math.ceil(ans))


(r, x, y, x1, y1) = map(int, input().split())
d = 2 * r
if x == x1 and y == y1:
	print(0)
else:
	a = (x - x1) * (x - x1) + (y - y1) * (y - y1)
	a = a ** 0.5
	if a == int(a):
		if int(a) % d == 0:
			print(int(a // d))
		else:
			print(int(a // d) + 1)
	else:
		print(int(a // d) + 1)


import math
(r, x, y, xx, yy) = map(int, input().split())
if x == xx and y == yy:
	print(0)
else:
	dis = (xx - x) ** 2 + (yy - y) ** 2
	d = math.sqrt(abs(dis))
	pins = math.ceil(d / (2 * r))
	print(pins)


(r, x, y, xx, yy) = [int(x) for x in input().split()]
steps = 0
dis = (x - xx) ** 2 + (y - yy) ** 2
dis = dis ** 0.5
if dis % 1 != 0 or dis % (2 * r) != 0:
	steps += 1
steps += dis // (2 * r)
print(int(steps))


import math
(r, x, y, x1, y1) = map(int, input().split())
yd = (y1 - y) * (y1 - y)
xd = (x1 - x) * (x1 - x)
pd = math.sqrt(yd + xd)
if pd // (r * 2) == pd / (r * 2):
	print(int(pd // (r * 2)))
else:
	print(int(pd // (r * 2) + 1))


(radius, x1, y1, x2, y2) = map(int, input().split())
distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
answer = distance // (2 * radius)
if distance % (2 * radius) != 0:
	answer += 1
print(int(answer))


(r, x1, y1, x2, y2) = map(int, input().split())
import math as m
ras = m.sqrt(abs(x1 - x2) ** 2 + abs(y2 - y1) ** 2)
k = ras / (r * 2)
print(m.ceil(k))


import random
from sys import stdin
input = stdin.readline

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a * b / gcd(a, b)
(r, x, y, x1, y1) = map(int, input().split())
d = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
if d % (2 * r) == 0:
	print(int(d // (2 * r)))
else:
	print(int(d // (2 * r) + 1))


import math
arr = list(map(int, input().split()))
print(math.ceil(float(((arr[1] - arr[3]) * (arr[1] - arr[3]) + (arr[2] - arr[4]) * (arr[2] - arr[4])) ** 0.5) / (2 * arr[0])))


import math
line = input().split()
line = [int(i) for i in line]
print(math.ceil(((line[4] - line[2]) ** 2 + (line[3] - line[1]) ** 2) ** 0.5 / 2 / line[0]))


from math import sqrt
s = input().split()
s = [int(s) for s in s]
(r, x, y, x1, y1) = (s[0], s[1], s[2], s[3], s[4])
d = sqrt((x - x1) ** 2 + (y - y1) ** 2)
ans = d // (r * 2)
if d > ans * r * 2:
	ans += 1
print(int(ans))


import math
(a, b, c, d, e) = input().split()
r = int(a)
x1 = int(b)
y1 = int(c)
x2 = int(d)
y2 = int(e)
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if d != 0:
	print(math.ceil(d / (2 * r)))
if d == 0:
	print(0)


(r, x, y, x1, y1) = map(int, input().split())
res = 0
dist2 = (x - x1) ** 2 + (y - y1) ** 2
dist = 0
while dist ** 2 < dist2:
	res += 1
	dist += 2 * r
print(res)


import math
data = input()
r = int(data[:data.find(' ')])
data = data[data.find(' ') + 1:]
x1 = int(data[:data.find(' ')])
data = data[data.find(' ') + 1:]
y1 = int(data[:data.find(' ')])
data = data[data.find(' ') + 1:]
x2 = int(data[:data.find(' ')])
data = data[data.find(' ') + 1:]
y2 = int(data)
dx = abs(x2 - x1)
dy = abs(y2 - y1)
moving = math.pow(dx, 2) + math.pow(dy, 2)
moving = math.sqrt(moving)
steps = moving / (2 * r)
if steps % 1 != 0:
	steps = int(steps) + 1
print(int(steps))


import math
cor = [int(x) for x in input().split()]
r = cor[0]
d = math.sqrt((cor[1] - cor[3]) ** 2 + (cor[2] - cor[4]) ** 2)
if d % (2 * r) == 0:
	print(int(d / (r * 2)))
else:
	print(int(d / (r * 2)) + 1)


from math import *
(r, x, y, x1, y1) = map(int, input().split())
print(ceil((pow(x - x1, 2) + pow(y - y1, 2)) ** 0.5 / (2 * r)))


import sys
input = sys.stdin.readline
(r, x, y, xx, yy) = map(int, input().split())
dist = ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5
ans = dist / (2 * r)
if ans % 1 == 0:
	print(int(ans))
else:
	print(int(ans) + 1)


import math

def ceil(a, b):
	return -(-a // b)

def answer(r, x, y, xp, yp):
	d = math.sqrt((xp - x) ** 2 + (yp - y) ** 2)
	num_rs = ceil(d, 2 * r)
	return int(num_rs)

def main():
	(r, x, y, xp, yp) = [int(i) for i in input().split()]
	print(answer(r, x, y, xp, yp))
	return
main()


from sys import *

def solve():
	pass
test = 1
for t in range(0, test):
	(r, x, y, x1, y1) = list(map(int, input().split()))
	import math
	dist = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	val = math.ceil(dist / (2 * r))
	print(val)


import math
INPUT = input()
INPUT = INPUT.split(' ')
r = int(INPUT[0])
x1 = int(INPUT[1])
y1 = int(INPUT[2])
x2 = int(INPUT[3])
y2 = int(INPUT[4])
r = 2 * r
dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
res = dist / r
if res.is_integer():
	print(int(res))
else:
	print(int(res) + 1)


def rotations(r, x, y, a, b):
	dist = ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	i = 0
	while dist > 0:
		dist -= 2 * r
		i += 1
	return i
A = list(map(int, input().split(' ')))
print(rotations(A[0], A[1], A[2], A[3], A[4]))


import decimal
import math
(r, x, y, x1, y1) = map(decimal.Decimal, input().split())
r *= decimal.Decimal('2')
R = ((x - x1) ** 2 + (y - y1) ** 2) ** decimal.Decimal('0.5')
eps = decimal.Decimal('0.000000001')
print(math.floor((R + r - eps) / r))


import math
x = [int(x) for x in input().split()]
a = math.ceil(math.sqrt((x[1] - x[3]) * (x[1] - x[3]) + (x[2] - x[4]) * (x[2] - x[4])) / (x[0] + x[0]))
print(a)


from math import ceil, sqrt
t = input().split()
t = list(map(int, t))
r = t[0]
x = t[1]
y = t[2]
a = t[3]
b = t[4]
d = sqrt((x - a) ** 2 + (y - b) ** 2)
if d == 0:
	res = 0
elif r > d:
	res = 1
else:
	res = ceil(d / (2 * r))
print(res)


from math import hypot, ceil
(r, x, y, x1, y1) = map(int, input().split(' '))
(c_x, c_y) = (abs(x - x1), abs(y - y1))
c = ceil(hypot(c_x, c_y) / (2 * r))
print(c)


from math import sqrt

def main():
	(r, x, y, a, b) = map(int, input().split())
	d = sqrt((b - y) ** 2 + (a - x) ** 2)
	if d % (2 * r) == 0:
		print(int(d / (2 * r)))
	else:
		print(int(d / (2 * r) + 1))
main()


from math import ceil
(r, x1, y1, x2, y2) = map(int, input().strip().split())
dist = ((y2 - y1) ** 2 + (x2 - x1) ** 2) ** 0.5
print(ceil(dist / (2 * r)))


from math import sqrt
from math import ceil
rxyxdyd = input()
(r, x, y, xd, yd) = [int(i) for i in rxyxdyd.split(' ')]
dis = sqrt((xd - x) ** 2 + (yd - y) ** 2)
n = ceil(dis / (2 * r))
print(n)


import math
(radius, x1, y1, x2, y2) = map(int, input().split())
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
x = math.ceil(d / (2 * radius))
print(int(x))


from math import ceil
(r, a, b, c, d) = map(int, input().split())
s = pow(pow(abs(c - a), 2) + pow(abs(d - b), 2), 0.5)
print(ceil(s / (2 * r)))


from math import hypot, fabs, ceil
(d, xx, yy, x, y) = map(int, input().split())
d *= 2
dist = hypot(fabs(xx - x), fabs(yy - y))
print(ceil(dist / d))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
Distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
ans = math.ceil(Distance / (2 * r))
print(ans)


import math
(r, x, y, x_, y_) = [int(i) for i in input().split()]
dist = math.sqrt((x - x_) ** 2 + (y - y_) ** 2)
result = math.ceil(dist / (2 * r))
print(result)


import math

def pins(r, a, b, c, d):
	dist = ((c - a) ** 2 + (d - b) ** 2) ** 0.5
	return math.ceil(dist / 2 / r)
(r, a, b, c, d) = map(int, input().split())
result = pins(r, a, b, c, d)
print(result)


(r, x, y, x_, y_) = map(int, input().split(' '))
import math
dist = math.sqrt((x - x_) ** 2 + (y - y_) ** 2)
print(math.ceil(dist / (2 * r)))


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

def distance(x1, x2, y1, y2):
	b1 = (y2 - y1) ** 2
	b2 = (x2 - x1) ** 2
	return math.sqrt(b1 + b2)
d = distance(x1, x2, y1, y2)
one_move = 2 * r
print(math.ceil(d / one_move))


import math
a = [int(i) for i in input().split()]
b = math.sqrt((a[1] - a[3]) ** 2 + (a[2] - a[4]) ** 2)
print(math.ceil(b / (2 * a[0])))


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline

def factors(n):
	return sorted(list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))))

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
(r, a, b, x, y) = li()

def dist(a, b, x, y):
	return ((a - x) ** 2 + (b - y) ** 2) ** 0.5
d = dist(a, b, x, y)
print(math.ceil(d / (2 * r)))


import math
(r, x, y, a, b) = list(map(int, input().split()))
kc = math.sqrt((a - x) * (a - x) + (b - y) * (b - y))
ans = int(kc / 2 / r)
res = ans * 2 * r
if kc - res == 0:
	print(ans)
else:
	print(ans + 1)


import math

def moves(r, x, y, x1, y1):
	st = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	return math.ceil(st / (2 * r))
(r, x, y, x1, y1) = map(int, input().split())
print(moves(r, x, y, x1, y1))


import math
(r, x0, y0, x1, y1) = list(map(int, input().split()))
print(math.ceil(math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2) * 0.5 / r))


import math
(r, x, y, u, v) = map(int, input().split())
d = math.sqrt((u - x) ** 2 + (v - y) ** 2) / (2 * r)
if d != int(d):
	d += 1
print(int(d))


import math

def dist(x, y, x1, y1):
	return ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
(r, x, y, xz, yz) = [int(i) for i in input().split()]
q = dist(x, y, xz, yz)
print(math.ceil(q / (2 * r)))


from math import ceil

def sq(x):
	return x * x
(r, x, y, x1, y1) = map(int, input().split())
r = r * 2
dist = sq(x1 - x) + sq(y1 - y)
dist = dist ** 0.5
print(ceil(dist / r))


import sys
import math
(r, x, y, x1, y1) = map(int, sys.stdin.readline().split())
ans = 0
if x1 == x and y1 == y:
	ans = 0
else:
	d = math.sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y))
	ans = math.ceil(d / 2 / r)
print(ans)


import math
(r, x, y, x1, y1) = [int(var) for var in input().split()]
d = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
val = d / (r * 2)
if val == round(val):
	print(int(val))
else:
	print(int(val) + 1)


import math
(r, x, y, p, q) = map(int, input().split())
dist = math.sqrt((x - p) ** 2 + (y - q) ** 2)
print(math.ceil(dist / (2 * r)))


def up(x):
	if int(x) == x:
		return int(x)
	else:
		return int(x) + 1
(r, x, y, x1, y1) = map(int, input().split())
import math
dis = math.sqrt((y1 - y) ** 2 + (x1 - x) ** 2)
print(up(dis / (2 * r)))


import math

def main():
	(r, x1, y1, x2, y2) = map(int, input().split())
	d = int((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
	print(math.ceil(d / (2 * r)))
main()


import math
(r, x, y, x_, y_) = map(int, input().split())
z = math.sqrt((x_ - x) ** 2 + (y_ - y) ** 2)
result = math.ceil(z / (int(r) * 2))
print(result)


from math import *
s1 = input()
s2 = s1.split()
for i in range(5):
	s2[i] = int(s2[i])
(r, x, y, x1, y1) = (s2[0], s2[1], s2[2], s2[3], s2[4])
dis = hypot(x - x1, y - y1)
ans = ceil(dis / (2 * r))
print(ans)


import math
inp = input()
(r, x1, y1, x2, y2) = list(map(int, inp.split(' ')))
dist = math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
if dist // (2 * r) * 2 * r == dist:
	print(int(dist // (2 * r)))
else:
	print(int(dist // (2 * r) + 1))


import math
t = input().split(' ')
r = int(t[0])
x1 = int(t[1])
y1 = int(t[2])
x2 = int(t[3])
y2 = int(t[4])
dist = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
dist = math.sqrt(dist)
count = dist // (2 * r)
if dist % (2 * r) != 0:
	count += 1
print(int(count))


import math
user_input = input()
numbers = user_input.split(' ')
move = 0
r = int(numbers[0])
old_x = int(numbers[1])
old_y = int(numbers[2])
new_x = int(numbers[3])
new_y = int(numbers[4])
if new_x == old_x and new_y == old_y:
	move = 0
else:
	distance = math.sqrt((new_x - old_x) * (new_x - old_x) + (new_y - old_y) * (new_y - old_y))
	move = distance // (2 * r)
	if distance % (2 * r) != 0:
		move += 1
print(int(move))


from math import *
(r, a, b, c, d) = [int(i) for i in input().split()]
dist = ceil(sqrt((a - c) ** 2 + (b - d) ** 2))
print(ceil(dist / (2 * r)))


import math
(r, x, y, x2, y2) = input().split()
r = int(r)
x = float(x)
y = float(y)
x2 = float(x2)
y2 = float(y2)
dist = math.sqrt(pow(x - x2, 2) + pow(y - y2, 2))
resp = int(dist / (2 * r))
comp = resp * r * 2
if comp != dist:
	resp += 1
print(resp)


from math import ceil
line = input().split()
r = int(line[0])
x = int(line[1])
y = int(line[2])
nx = int(line[3])
ny = int(line[4])
dist = ((nx - x) ** 2 + (ny - y) ** 2) ** 0.5
print(ceil(dist / (r * 2)))


import math
(r, x, y, i, j) = map(int, input().split())
x = abs(x - i)
y = abs(y - j)
print(math.ceil((x ** 2 + y ** 2) ** 0.5 / (2 * r)))


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

def dist(p1, p2):
	x = p1[0] - p2[0]
	y = p1[1] - p2[1]
	return math.sqrt(x ** 2 + y ** 2)
print(math.ceil(dist((x1, y1), (x2, y2)) / (2 * r)))


import math

def cordis(a1, b1, a2, b2, r):
	asq = (a2 - a1) ** 2
	bsq = (b2 - b1) ** 2
	return math.sqrt(asq + bsq) - 2 * r
inplt = list(map(int, input().split()))
(r, x1, y1, x2, y2) = [i for i in inplt]
if x1 == x2 and y1 == y2:
	print(0)
else:
	dip = cordis(x1, y1, x2, y2, r)
	if dip <= 0:
		print(1)
	else:
		stp = math.ceil(dip / (2 * r))
		print(stp + 1)


from math import sqrt
(r, x, y, nx, ny) = [int(element) for element in input().split(' ')]
distance = sqrt((x - nx) ** 2 + (y - ny) ** 2)
answer = distance // (2 * r)
if distance % (2 * r) != 0:
	answer += 1
print(int(answer))


import sys

def get_ints():
	return list(map(int, sys.stdin.readline().strip().split()))
import math
arr = get_ints()
r = arr[0]
x1 = arr[1]
y1 = arr[2]
x2 = arr[3]
y2 = arr[4]
diff = math.sqrt((y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1))
print(math.ceil(diff / (2 * r)))


from math import *
(r, x, y, nx, ny) = map(int, input().split())
d = hypot(abs(x - nx), abs(y - ny))
print(ceil(d / (2 * r)))


from sys import *
import math

def distance(x, y, x1, y1):
	dis = math.sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y))
	return dis

def steps(r, x, y, x1, y1):
	if distance(x, y, x1, y1) % (2 * r) == 0:
		return int(distance(x, y, x1, y1) / (2 * r))
	else:
		return int(distance(x, y, x1, y1) / (2 * r)) + 1
a = [0, 0, 0, 0, 0]
a = list(map(int, input().strip().split()))[:5]
(r, x, y, x1, y1) = (a[0], a[1], a[2], a[3], a[4])
print(steps(r, x, y, x1, y1))


import math
l1 = [int(x) for x in input().split()]
r = l1[0]
x1 = l1[1]
y1 = l1[2]
x2 = l1[3]
y2 = l1[4]
dis = (x2 - x1) ** 2 + (y2 - y1) ** 2
dis = dis ** 0.5
if dis == 0:
	print('0')
else:
	step = 0
	while dis > 2 * r:
		step += 1
		dis -= 2 * r
	print(step + 1)


import math

def no_of_steps(r, xi, yi, xf, yf):
	distance = math.sqrt((xf - xi) ** 2 + (yf - yi) ** 2)
	if distance % (2 * r) == 0:
		return int(distance) // (2 * r)
	else:
		return int(distance) // (2 * r) + 1
data = list(map(int, input().split()))
r = data[0]
(xi, yi) = (data[1], data[2])
(xf, yf) = (data[3], data[4])
print(no_of_steps(r, xi, yi, xf, yf))


import math
(r, x, y, a, b) = map(int, input().split())
l = (abs(x - a) ** 2 + abs(y - b) ** 2) ** 0.5
print(math.ceil(l / (r * 2)))


import math
[r, a, b, x, y] = [int(item) for item in input().split(' ')]
a -= x
a *= a
b -= y
b *= b
steps = int(math.ceil(math.sqrt(a + b) / (2 * r)))
print(steps)


[r, x1, y1, x2, y2] = list(map(int, input().split(' ')))
dx = max(x2 - x1, x1 - x2)
dy = max(y2 - y1, y1 - y2)
d = (dx * dx + dy * dy) ** 0.5
d = int(d) + (1 if int(d) * int(d) < dx * dx + dy * dy else 0)
result = d // (2 * r) + (1 if d % (2 * r) > 0 else 0)
print(result)


(r, a, b, c, d) = map(int, input().split())
t = (a - c) * (a - c) + (b - d) * (b - d)
t = t ** (1 / 2)
if t / r / 2 == int(t / r / 2):
	print(int(t / r / 2))
else:
	print(int(t / r / 2) + 1)


import math
input_list = input().split()
r = int(input_list[0])
x_o = int(input_list[1])
y_o = int(input_list[2])
x_d = int(input_list[3])
y_d = int(input_list[4])
distance = math.sqrt(math.pow(x_o - x_d, 2) + math.pow(y_o - y_d, 2))
step = math.ceil(distance / (2 * r))
print(step)


inp = list(map(int, input().split()))
r = inp[0]
x1 = inp[1]
y1 = inp[2]
x2 = inp[3]
y2 = inp[4]
d = pow((x1 - x2) ** 2 + (y1 - y2) ** 2, 0.5)
d_in = int(d)
flag = 1
if x1 == x2 and y1 == y2:
	print(0)
	flag = 0
if d <= 2 * r and flag == 1:
	print(1)
	flag = 0
if d == d_in and flag == 1:
	if d_in % (2 * r) == 0:
		print(int((d_in - 2 * r) // (2 * r)) + 1)
		flag = 0
if flag == 1:
	print(int((d - 2 * r) // (2 * r)) + 2)


import math
(r, x, y, xp, yp) = tuple(map(int, input().split()))
d = math.sqrt(math.pow(abs(x - xp), 2) + math.pow(abs(y - yp), 2))
print(math.ceil(d / (2 * r)))


(r, x, y, xp, yp) = list(map(int, input().split()))
dist = (x - xp) ** 2 + (y - yp) ** 2
for k in range(200001):
	if k * k * 4 * r * r >= dist:
		break
print(k)


import math
string = input()
numbers = string.split(' ')
for x in range(5):
	numbers[x] = int(numbers[x])
r = numbers[0]
x1 = numbers[1]
y1 = numbers[2]
x2 = numbers[3]
y2 = numbers[4]
d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(math.ceil(math.ceil(d / r) / 2))


from math import sqrt
(r, x, y, xx, yy) = map(int, input().split())
distance = sqrt((xx - x) * (xx - x) + (yy - y) * (yy - y))
diameter = 2 * r
ans = distance // diameter
if distance % diameter != 0:
	ans += 1
print(round(ans))


import math
(r, x1, y1, x2, y2) = [int(i) for i in input().split()]
print(math.ceil(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) / (2 * r)))


import math
(r, x, y, x1, y1) = map(int, input().split())
dis = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
fd = dis
ans1 = int(fd / (2 * r))
ans2 = fd % (2 * r)
if ans2 > 0:
	print(ans1 + 1)
else:
	print(ans1)


eps = 1e-10
(r, x1, y1, x2, y2) = map(int, input().split())
k = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
r *= 2
print(int((k + r - eps) // r))


import math

def solve():
	(r, x1, y1, x2, y2) = map(int, input().split())
	dist = math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
	R = r * 2
	return math.ceil(dist / R)
print(solve())


(r, a, b, x, y) = [int(i) for i in input().split()]
dis = ((x - a) ** 2 + (y - b) ** 2) ** (1 / 2)
import math
print(math.ceil(dis / (2 * r)))


import math
a = list(input().split())
r = int(a[0])
x = int(a[1])
y = int(a[2])
p = int(a[3])
q = int(a[4])
sum1 = 0
k = 0
sum1 = math.sqrt((x - p) ** 2 + (y - q) ** 2)
r = 2 * r
while sum1 >= r:
	sum1 = sum1 - r
	k = k + 1
if sum1 >= r / 2:
	leng = math.sqrt(sum1 ** 2 - (r / 2) ** 2)
else:
	leng = 0
if sum1 == 0:
	print(int(k))
elif sum1 - r / 2 > leng:
	print(int(k + 2))
else:
	print(int(k + 1))


from math import sqrt, ceil

def main():
	(r, x, y, X, Y) = map(int, input().split())
	d = sqrt((x - X) ** 2 + (y - Y) ** 2)
	print(ceil(d / (2 * r)))
main()


from math import sqrt
(r, a, b, x, y) = [int(v) for v in input().split()]
z = sqrt((x - a) ** 2 + (y - b) ** 2)
if z % (2 * r) == 0:
	print(int(z // (2 * r)))
else:
	print(int(z // (2 * r) + 1))


import math

def calculateDistance(x1, y1, x2, y2):
	dist = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	return dist
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y == y1:
	print(0)
else:
	print(math.ceil(calculateDistance(x, y, x1, y1) / (2 * r)))


import math
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y == y1:
	print(0)
	quit()
distance = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
print(math.ceil(distance / (2 * r)))


import math

def distance(a, b):
	m = len(a)
	c = 0
	for i in range(m):
		c += (a[i] - b[i]) ** 2
	return c ** 0.5

def solve(a, b, r):
	return math.ceil(distance(a, b) / (2 * r))
(r, x0, y0, x1, y1) = [int(s) for s in input().split(' ')]
print(solve((x0, y0), (x1, y1), r))


import math

def steps(r, x, y, x1, y1):
	distance = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	if distance % (2 * r) == 0:
		return int(distance // (2 * r))
	else:
		return int(distance // (2 * r) + 1)
l = list(map(int, list(input().split())))
print(steps(l[0], l[1], l[2], l[3], l[4]))


def main():
	from sys import stdin, stdout
	from math import ceil, sqrt

	def sqr(a):
		return a * a
	(r, x, y, a, b) = map(int, stdin.readline().split())
	mid = ((x + a) / 2, (y + b) / 2)
	dis = sqrt(sqr(x - mid[0]) + sqr(y - mid[1]))
	n = ceil(dis / r)
	stdout.write(str(n) + '\n')
main()


import math
arr = list(map(int, input().split()))
(r, x, y, x1, y1) = (arr[0], arr[1], arr[2], arr[3], arr[4])
d = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
if d % (r * 2) == 0:
	print(int(d // (2 * r)))
elif d < 2 * r:
	print(1)
elif d < 4 * r:
	print(2)
else:
	step = 0
	while d > 4 * r:
		d = d - 2 * r
		step += 1
	print(step + 2)


import math
(r, x, y, x1, y1) = map(int, input().split())
d = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
angle = 0
if x1 - x == 0:
	angle = math.pi / 2
else:
	angle = math.atan((y1 - y) / (x1 - x))
if angle != 0:
	print(int(math.ceil(abs(d / (2 * r)))))
else:
	print(abs(math.ceil((x1 - x) / (2 * r))))


import math
(r, a, b, x, y) = map(int, input().split())
print(math.ceil(math.hypot(a - x, b - y) / 2 / r))


import math
(r, a, b, c, d) = [int(_) for _ in input().split()]
print(math.ceil(abs((a - c) ** 2 + (b - d) ** 2) ** (1 / 2) / (2 * r)))


from math import ceil

def dist(x, y):
	return (x ** 2 + y ** 2) ** 0.5
(r, x, y, x2, y2) = map(int, input().split())
print(ceil(dist(x - x2, y - y2) / (2 * r)))


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
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')

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

def array():
	return [int(i) for i in input().split()]
(r, x1, y1, x2, y2) = value()
d = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(ceil(d / (2 * r)))


import os
import sys
from io import BytesIO, IOBase
import math

def main():
	(r, x1, y1, x2, y2) = map(int, input().split(' '))
	print(math.ceil(math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2) / (2 * r)))
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')
main()


from math import *
(r, x, y, x1, y1) = [int(i) for i in input().split()]
l = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(ceil(l / (2 * r)))


(r, x, y, x1, y1) = list(map(int, input().split(' ')))

def amir(r, x, y, x1, y1):
	d = ((x1 - x) ** 2 + (y1 - y) ** 2) ** (1 / 2)
	if d % (2 * r) == 0:
		print(int(d / (2 * r)))
		return
	else:
		if d < 2 * r:
			print(1)
			return
		print(int(d // (2 * r)) + 1)
		return
amir(r, x, y, x1, y1)


from math import hypot, ceil
(r, x, y, x1, y1) = map(float, input().split())
d = hypot(x - x1, y - y1)
k = ceil(d / (2 * r))
print(k)


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

def distance(args):
	(x1, x2, y1, y2) = args
	return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
d = distance([x1, x2, y1, y2])
if d == 0:
	print(0)
else:
	print(math.ceil(d / (2 * q)))


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from math import *
(r, x, y, p, q) = f()
print(ceil((abs(p - x) ** 2 + abs(q - y) ** 2) ** 0.5 / (2 * r)))


import math
(n, a, b, c, d) = [int(i) for i in input().split()]
t = math.sqrt((c - a) ** 2 + (d - b) ** 2)
print(math.ceil(t / (n * 2)))


import sys, math
from itertools import groupby
sys.setrecursionlimit(1000000000)
lines = []
for Line in sys.stdin:
	lines.append(Line.rstrip('\n'))
(r, x, y, x1, y1) = list(map(int, lines[0].split()))
del lines[0]
d = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
m = d / (r * 2)
if m > round(m):
	print(round(m + 1))
else:
	print(round(m))


import math
(r, x, y, x_n, y_n) = (int(x) for x in input().split())
dist = math.sqrt((x_n - x) ** 2 + (y_n - y) ** 2)
answer = 0
while dist > 0:
	answer += 1
	dist -= 2 * r
print(answer)


import math
(r, x, y, a, b) = map(int, input().split())
hd = abs(a - x)
vd = abs(b - y)
d = math.sqrt(hd * hd + vd * vd)
count = int(d // (2 * r))
if d % (r * 2) != 0:
	count += 1
print(count)


import math
a = [int(x) for x in input().split()]
distance_x = abs(a[3] - a[1])
distance_y = abs(a[4] - a[2])
distance = math.sqrt(distance_x ** 2 + distance_y ** 2)
print(math.ceil(distance / (a[0] * 2)))


from math import *
(r, x, y, x1, y1) = map(int, input().split())
res1 = (y1 - y) ** 2
res2 = (x1 - x) ** 2
res = (res1 + res2) ** 0.5
print(ceil(res / (2 * r)))


from math import ceil
(r, x1, y1, x2, y2) = list(map(int, input().split()))
dist = ceil((abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2) ** 0.5)
print(dist // (2 * r) + 1 - (2 * r - dist % (2 * r)) // (2 * r))


import math
(r, x, y, xd, yd) = (int(x) for x in input().split())
print(math.ceil(math.sqrt(pow(x - xd, 2) + pow(y - yd, 2)) / (2 * r)))


def solve(r, xa, ya, xb, yb):
	d = ((xa - xb) ** 2 + (ya - yb) ** 2) ** 0.5
	return -int(-d // (2 * r))

def test():
	f = lambda st: list(map(int, st.split()))
	assert solve(*f('2 0 0 0 4')) == 1
	assert solve(*f('1 1 1 4 4')) == 3
	assert solve(*f('4 5 6 5 6')) == 0
res = solve(*list(map(int, input().split())))
print(res)


import math
a = list(map(int, input().split()))
if a[1] == a[3] and a[2] == a[4]:
	print(0)
else:
	if math.sqrt((a[1] - a[3]) * (a[1] - a[3]) + (a[2] - a[4]) * (a[2] - a[4])) % (2 * a[0]) == 0:
		s = math.sqrt((a[1] - a[3]) * (a[1] - a[3]) + (a[2] - a[4]) * (a[2] - a[4])) / (2 * a[0])
	else:
		s = math.sqrt((a[1] - a[3]) * (a[1] - a[3]) + (a[2] - a[4]) * (a[2] - a[4])) / (2 * a[0]) + 1
	print(int(s))


import math
(r, x, y, x_d, y_d) = map(int, input().split(' '))
dist = (x_d - x) * (x_d - x) + (y_d - y) * (y_d - y)
dist = math.sqrt(dist)
ans = math.ceil(dist / (2 * r))
print(ans)


import math
(r, x, y, a, b) = map(int, input().split())
if x == a and y == b:
	print('0')
else:
	print(math.ceil(math.sqrt((a - x) ** 2 + (b - y) ** 2) / (2 * r)))


from math import sqrt, ceil
(r, x, y, newx, newy) = map(int, input().split())
dist = sqrt((x - newx) ** 2 + (y - newy) ** 2)
turns = ceil(dist / (2 * r))
print(turns)


gi = lambda : list(map(int, input().strip().split()))
(r, x, y, a, b) = gi()
d = ((x - a) ** 2 + (y - b) ** 2) ** 0.5
ans = int(d / (2 * r))
if d / (2 * r) - int(d / (2 * r)) > 0:
	ans += 1
print(ans)


import math
(r, x, y, a, b) = map(int, input().split())
dist = math.sqrt((x - a) ** 2 + (y - b) ** 2)
if dist % (2 * r) == 0:
	print(int(dist // (2 * r)))
else:
	print(int(dist // (2 * r)) + 1)


import math

def ans():
	(r, x1, y1, x2, y2) = [int(i) for i in input().split()]
	d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	if d % (2 * r) == 0:
		print(int(d / (2 * r)))
	else:
		print(int(d / (2 * r)) + 1)
	return
ans()


import math
from math import *
(r, x, y, x1, y1) = [int(x) for x in input().split()]
dist = sqrt((x - x1) ** 2 + (y - y1) ** 2)
ans = dist / (r * 2)
print(math.ceil(ans))


import math
values = input()
values = values.split()
r = int(values[0])
x1 = int(values[1])
y1 = int(values[2])
x2 = int(values[3])
y2 = int(values[4])
form = math.sqrt(pow(y2 - y1, 2) + pow(x2 - x1, 2))
print(int(math.ceil(form / r / 2)))


import math
(r, a, b, x, y) = map(int, input().split())
dis = math.sqrt((a - x) ** 2 + (b - y) ** 2)
count = 0
while True:
	if dis == 0:
		break
	elif dis <= r:
		count += 1
		break
	elif dis > r and dis < 2 * r:
		count += 1
		break
	elif dis >= 2 * r:
		dis -= 2 * r
		count += 1
print(count)


(a, b, c, d, e) = map(int, input().split())
f = 2 * a
g = ((b - d) ** 2 + (e - c) ** 2) ** 0.5
print(0 if g == 0 else int(g // f) if int(g) == g and g % f == 0 else int(g // f + 1))


import math
(r, x, y, x1, y1) = map(int, input().split())
t = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
q = 2 * r
u = math.ceil(t / q)
print(u)


from math import ceil, sqrt
(r, x, y, a, b) = map(int, input().split())
p = sqrt((a - x) ** 2 + (b - y) ** 2)
print(ceil(p / (2 * r)))


fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from re import *
from sys import *
from math import *
from heapq import *
from queue import *
from bisect import *
from string import *
from itertools import *
from collections import *
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from collections import Counter as cc
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def output(answer):
	stdout.write(str(answer))
(r, x, y, x0, y0) = zzz()
dis = ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5
print(ceil(dis / (2 * r)))


from math import sqrt, ceil
(r, x, y, x2, y2) = map(int, input().split())
d = sqrt(pow(x - x2, 2) + pow(y - y2, 2))
s = int(ceil(d / (2 * r)))
print(s)


import math
(r, x, y, xx, yy) = map(int, input().split())
dis = math.sqrt(math.pow(xx - x, 2) + math.pow(yy - y, 2))
dis = math.ceil(dis / (2 * r))
if x == xx and y == yy:
	dis = 0
print(dis)


a = input()
A = list(map(int, list(a.split())))
r = A[0]
x1 = A[1]
y1 = A[2]
x2 = A[3]
y2 = A[4]
m = abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2
if m ** (1 / 2) % (2 * r) == 0:
	print(int(m ** (1 / 2) // (2 * r)))
else:
	print(int(m ** (1 / 2) // (2 * r)) + 1)


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
from math import ceil
import math
(r, x, y, a, b) = ei()
d = math.sqrt((a - x) ** 2 + (b - y) ** 2)
print(ceil(d / (2 * r)))


(n, x, y, X, Y) = map(int, input().split())
distance = ((X - x) ** 2 + (Y - y) ** 2) ** 0.5
if distance == 0:
	print(0)
if 0 < distance <= n:
	print(1)
x = (distance - n) // (2 * n)
y = (distance - n) % (2 * n)
if 0 <= y <= n and distance > n:
	print(int(1 + x))
if y > n and distance > n:
	print(int(2 + x))


from math import sqrt
l = list(map(int, input().split()))
(r, x, y, xn, yn) = (l[0], l[1], l[2], l[3], l[4])
d = sqrt((x - xn) ** 2 + (y - yn) ** 2)
if d % (2 * r) == 0:
	print(int(d / (2 * r)))
else:
	print(int(d // (2 * r) + 1))


from math import *
l = [int(x) for x in input().split()]
(r, x, y, x1, y1) = (l[0], l[1], l[2], l[3], l[4])
z = sqrt((x - x1) ** 2 + (y - y1) ** 2)
a = 2 * r
if z % a == 0:
	print(int(z // a))
else:
	print(1 + int(z // a))


from math import sqrt, ceil

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

def main():
	(r, x1, y1, x2, y2) = map(int, input().split())
	dist = dis(x1, y1, x2, y2)
	print(ceil(dist / (2 * r)))
main()


import os
import sys
import math
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def npr(n, r):
	return math.factorial(n) // math.factorial(n - r)

def seive(n):
	primes = [True] * (n + 1)
	ans = []
	for i in range(2, n):
		if not primes[i]:
			continue
		j = 2 * i
		while j <= n:
			primes[j] = False
			j += i
	for p in range(2, n + 1):
		if primes[p]:
			ans += [p]
	return ans

def factors(n):
	factors = []
	x = 1
	while x * x <= n:
		if n % x == 0:
			if n // x == x:
				factors.append(x)
			else:
				factors.append(x)
				factors.append(n // x)
		x += 1
	return factors
from math import ceil

def main():
	try:
		(r, x, y, x1, y1) = invr()
		print(ceil(((x - x1) ** 2 + (y - y1) ** 2) ** 0.5 / (2 * r)))
	except Exception as e:
		print(e)
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')
main()


from math import *
(r, x, y, a, b) = map(int, input().split())
z = (a - x) ** 2 + (b - y) ** 2
d = z ** 0.5
d = ceil(d / (2 * r))
print(d)


import math as m
(r, x, y, xp, yp) = map(int, input().split())
print(m.ceil((abs(x - xp) ** 2 + abs(y - yp) ** 2) ** 0.5 / (2 * r)))


import sys
import math as m

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l
mod = int(1000000000.0) + 7

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

def iinp():
	return int(input())

def ninp():
	return map(int, sys.stdin.readline().strip().split())

def linp():
	return list(map(int, sys.stdin.readline().strip().split()))

def p(a):
	print(a)

def p2(a, b):
	print(a, b)
(r, x, y, x1, y1) = ninp()
d = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
l = 2 * r
print(m.ceil(d / l))


(r, x, y, a, b) = map(int, input().split())
n = ((x - a) ** 2 + (y - b) ** 2) ** 0.5 / (2 * r)
if n == int(n):
	print(int(n))
else:
	print(int(n + 1))


import math
s = input().split()
s = [int(x) for x in s]
distance = math.sqrt((s[1] - s[3]) ** 2 + (s[2] - s[4]) ** 2)
x = distance / (2 * s[0])
if int(x) == x:
	print(int(x))
else:
	print(int(x) + 1)


import sys
import math
import itertools

def get_line():
	return list(map(int, sys.stdin.readline().strip().split()))

def in1():
	return int(input())
(r, x1, y1, x2, y2) = get_line()
t1 = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
t2 = t1 // (2 * r)
if t1 % (2 * r) == 0:
	print(int(t2))
else:
	print(int(t2) + 1)


(r, x, y, a, b) = [int(x) for x in input().strip().split()]
dis = ((a - x) ** 2 + (b - y) ** 2) ** 0.5
ct = 0
while dis > 0:
	dis -= 2 * r
	ct += 1
print(ct)


(r, x, y, x_, y_) = map(int, input().split())
dis = ((x - x_) ** 2 + (y - y_) ** 2) ** 0.5
print(int(dis // (2 * r)) + int(dis % (2 * r) != 0))


import math
input_value = input()
input_list = input_value.split()
circle_list = []
for i in input_list:
	i = int(i)
	circle_list.append(i)
r = circle_list[0]
x1 = circle_list[1]
y1 = circle_list[2]
x2 = circle_list[3]
y2 = circle_list[4]
distance = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
n = math.ceil(distance / (2 * r))
print(n)


import math

def Appel(arr):
	dobleR = arr[0] * 2
	dx = True
	dy = True
	distX = (arr[3] - arr[1]) ** 2
	distY = (arr[4] - arr[2]) ** 2
	distTot = math.sqrt(distX + distY)
	if arr[3] == arr[1]:
		dx = False
	if arr[4] == arr[2]:
		dy = False
	if dy == False and dx == False:
		return 0
	if dy or dx:
		result = distTot / dobleR
	return math.ceil(result)
arr = []
arr = list(map(int, input().strip().split()))
print(Appel(arr))


from sys import stdin
(r, x1, y1, x2, y2) = map(int, stdin.readline().rstrip().split(' '))
r = 2 * r
distance = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
res = distance // r
if distance % r:
	print(int(res + 1))
else:
	print(int(res))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
d = 2 * r
dist = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
if dist % d == 0:
	print(int(dist / d))
else:
	print(int(dist / d) + 1)


from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

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

def ceil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def mapin():
	return map(float, input().split())

def solve(a, b, size):
	msf = -1000000000.0
	meh = 0
	for i in range(b, size):
		meh = meh + a[i]
		if msf < meh:
			msf = meh
		if meh < 0:
			meh = 0
	return msf
t = 1
for _ in range(t):
	(r, x1, x2, x3, x4) = mapin()
	dis = (x4 - x2) ** 2
	dis2 = (x3 - x1) ** 2
	dis += dis2
	dis = math.sqrt(dis)
	r += r
	ans = math.ceil(dis / r)
	print(ans)


from collections import *
from bisect import *
from math import *
from heapq import *
from fractions import *
import sys
input = sys.stdin.readline
t = 1

def r(a):
	return a * (a - 1) // 2
while t:
	t -= 1
	(r, x, y, x1, y1) = map(int, input().split())
	d = pow(abs(x - x1), 2) + pow(abs(y - y1), 2)
	d = pow(d, 0.5)
	print(ceil(d / (2 * r)))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
(r, x1, y1, x2, y2) = L()
s = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
z = s // (2 * r)
if z * (2 * r) != s:
	z += 1
print(int(z))
endtime = time.time()


import sys
import math
import bisect

def main():
	(r, x1, y1, x2, y2) = map(int, input().split())
	dist = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	print(math.ceil(dist / (2 * r)))
main()


import math
nn = list(map(int, input().rstrip().split()))
dia = 2 * nn[0]
x = nn[1]
y = nn[2]
xx = nn[3]
yy = nn[4]
dist = math.sqrt((yy - y) * (yy - y) + (xx - x) * (xx - x))
numm = dist / dia
print(math.ceil(numm))


import math
(r, x1, y1, x2, y2) = input().split(' ')
r = int(r)
x1 = int(x1)
x2 = int(x2)
y1 = int(y1)
y2 = int(y2)
distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(math.ceil(distance / (2 * r)))


import math
n = input().split()
sdis = (int(n[3]) - int(n[1])) ** 2 + (int(n[4]) - int(n[2])) ** 2
dis = int(math.sqrt(sdis))
rad = 2 * int(n[0])
if dis * dis == sdis:
	if dis % rad == 0:
		print(dis // rad)
	else:
		print(dis // rad + 1)
else:
	print(dis // rad + 1)


(r, x, y, xx, yy) = map(int, input().split())
R = ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5
print(int(R // (2 * r) + 1 * int(R % (2 * r) != 0)))


a = input('').split(' ')
import math
newa = []
for val in a:
	newa.append(int(val))
y = newa[4] - newa[2]
x = newa[3] - newa[1]
print(math.ceil((x ** 2 + y ** 2) ** 0.5 / 2 / newa[0]))


import math

def solve(r, x0, y0, x1, y1):
	d = math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2)
	return math.ceil(d / (2 * r))
(r, x0, y0, x1, y1) = list(map(int, input().split(' ')))
print(solve(r, x0, y0, x1, y1))


import math
(r, x, y, x1, y1) = map(int, input().split())
d = pow(pow(x - x1, 2) + pow(y - y1, 2), 1 / 2)
moves = math.ceil(d / (2 * r))
print(moves)


import math
(r, x, y, x_n, y_n) = [int(i) for i in input().split()]
h = math.sqrt((x - x_n) ** 2 + (y - y_n) ** 2)
print(math.ceil(h / (2 * r)))


from math import ceil
a = list(map(int, input().split()))
print(ceil(((a[1] - a[3]) ** 2 + (a[2] - a[4]) ** 2) ** 0.5 / 2 / a[0]))


import math
from collections import defaultdict, deque
from bisect import bisect_left, bisect_right
(r, x, y, x1, y1) = map(int, input().split())
d = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
print(math.ceil(d / (r + r)))


(r, x, y, x2, y2) = map(int, input().split())
l = ((x - x2) ** 2 + (y - y2) ** 2) ** 0.5
print(-int(-l // (2 * r)))


import math
(r, x1, y1, x2, y2) = map(int, input().split())
m = math.sqrt(abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2)
d = r * 2
ans = m // d
if m % d > 0:
	ans += 1
ans = int(ans)
print(ans)


import math
(r, x1, y1, x2, y2) = map(int, input().split())
dx = abs(x1 - x2)
dy = abs(y1 - y2)
d = math.sqrt(dx ** 2 + dy ** 2)
print(math.ceil(d / (r * 2)))


from math import ceil
(r, x1, y1, x2, y2) = map(int, input().split())
from math import sqrt as S
d = S((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
d = ceil(d)
print(ceil(d / (2 * r)))


__author__ = 'Hippskill'
import math

def main():
	rdl = list(map(int, input().split()))
	way = math.sqrt((max(rdl[1], rdl[3]) - min(rdl[1], rdl[3])) ** 2 + (max(rdl[4], rdl[2]) - min(rdl[2], rdl[4])) ** 2)
	rdl[0] = rdl[0] * 2
	print(math.ceil(way / rdl[0]))
main()


mod = 1000000007
ssi = lambda : map(int, input().split())
from math import ceil
(r, x, y, x1, y1) = ssi()
a = pow(abs(x - x1), 2) + pow(abs(y - y1), 2)
dist = pow(a, 0.5)
res = ceil(dist / (2 * r))
print(res)


import math
s = input().split(' ')
r = int(s[0])
x = int(s[1])
y = int(s[2])
x1 = int(s[3])
y1 = int(s[4])
dist = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
num = math.ceil(dist / r / 2)
print(int(num))


(r, x, y, x1, y1) = [int(x) for x in input().split()]
distance = (abs(x - x1) ** 2 + abs(y - y1) ** 2) ** 0.5
print(0 if distance == 0 else int((distance - 1e-09) / (2 * r)) + 1)


import math
s = input()
ls = list()
ls = s.split()
for i in range(5):
	ls[i] = int(ls[i])
d = ((ls[3] - ls[1]) * (ls[3] - ls[1]) + (ls[2] - ls[4]) * (ls[2] - ls[4])) ** (1.0 / 2.0)
res = math.ceil(d / (2 * ls[0]))
print(res)


import math
aux = input().split(' ')
r = int(aux[0])
x1 = int(aux[1])
y1 = int(aux[2])
x2 = int(aux[3])
y2 = int(aux[4])
dist = math.sqrt(math.pow(y2 - y1, 2) + math.pow(x2 - x1, 2))
ans = math.ceil(dist / r / 2)
print(ans)


import math
a = list(map(int, input().split()))
d = math.ceil(math.sqrt((a[1] - a[3]) ** 2 + (a[2] - a[4]) ** 2))
print(math.ceil(d / (2 * a[0])))


from math import sqrt, ceil
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y1 == y:
	print(0)
	exit()
s = sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
if s == 2 * r:
	print(1)
if s < 2 * r:
	print(1)
if s > 2 * r:
	print(ceil(s / (2 * r)))


(a, b, c, d, e) = input().split(' ')
a = int(a)
b = int(b)
c = int(c)
d = int(d)
e = int(e)
a = 2 * a
x = ((b - d) ** 2 + (c - e) ** 2) ** 0.5
r = x / a
if int(r) == r:
	r -= 1
print(int(r) + 1)


import math
(r, x, y, x1, y1) = map(float, input().split())
print(math.ceil(math.hypot(x1 - x, y1 - y) / (2 * r)))


from math import sqrt, ceil

def distance(r, x1, y1, x2, y2):
	return ceil(sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) / (2 * r))
(R, X1, Y1, X2, Y2) = [int(i) for i in input().split()]
print(distance(R, X1, Y1, X2, Y2))


from sys import stdin, stdout
input = stdin.readline
(r, x, y, _x, _y) = map(int, input().split())
r *= 2
from math import ceil
ans = ceil(((_x - x) ** 2 + (_y - y) ** 2) ** 0.5 / r)
stdout.write(str(ans))


from math import sqrt, ceil
(r, x, y, X, Y) = [int(i) for i in input().split()]
dist = sqrt((x - X) ** 2 + (y - Y) ** 2)
print(ceil(dist / (2 * r)))


def distance(v_1, v_2):
	x = (v_1[0] - v_2[0]) ** 2
	y = (v_1[1] - v_2[1]) ** 2
	dis = (x + y) ** (1 / 2)
	return dis

def no_of_steps(r, c_1, c_2):
	steps = 0
	dis = distance(c_1, c_2)
	while dis > 0:
		steps += 1
		dis -= 2 * r
	return steps
l = list(map(int, input().strip().split()))
r = l[0]
c_1 = l[1:3]
c_2 = l[3:5]
print(no_of_steps(r, c_1, c_2))


import math
l = list(map(int, input().split()))
dist = math.sqrt(math.pow(l[4] - l[2], 2) + math.pow(l[3] - l[1], 2))
ans = math.ceil(dist / l[0] / 2)
print(ans)


import math
(r, x, y, x2, y2) = map(int, input().split())
dist_center = math.sqrt((x - x2) ** 2 + (y - y2) ** 2) // (2 * r)
if (dist_center * r * 2) ** 2 != (x - x2) ** 2 + (y - y2) ** 2:
	dist_center += 1
print(int(dist_center))


import math
(r, x, y, x1, y1) = map(int, input().split())
dist = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
if dist != int(dist):
	dist = int(dist) + 1
res = dist // (2 * r)
if dist % (2 * r) != 0:
	res = res + 1
print(int(res))


def up(a, b):
	if a / b == int(a / b):
		return a / b
	return int(a / b) + 1
(r, x, y, x1, y1) = map(int, input().split())
dis = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
print(int(up(dis, 2 * r)))


import math
(r, x, y, xr, yr) = list(map(int, input().split()))
d = math.sqrt((xr - x) ** 2 + (y - yr) ** 2)
n = math.ceil(d / (2 * r))
print(int(n))


from math import sqrt
ar = [int(s) for s in input().split()]
move = sqrt((ar[1] - ar[3]) ** 2 + (ar[2] - ar[4]) ** 2) / (2 * ar[0])
if int(move) == move:
	print(int(move))
else:
	print(int(move) + 1)


eps = 1e-07
from math import *
(r, x, y, x1, y1) = map(int, input().split())
d = sqrt((x - x1) ** 2 + (y - y1) ** 2)
if d < eps:
	print(0)
else:
	print(ceil(d / (2 * r)))


import math
(r, x, y, xNew, yNew) = (int(x) for x in input().split())
print(math.ceil(math.hypot(xNew - x, yNew - y) / (2 * r)))


from math import *
(a, b, c, d, e) = map(int, input().split())
print(ceil(hypot(b - d, c - e) / (2 * a)))


from math import ceil

def INPUT():
	return [int(x) for x in input().split(' ')]

def main():
	(r, x1, y1, x2, y2) = INPUT()
	dis = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
	ans = ceil(dis / (2 * r))
	print(ans)
main()


import sys, os, io
from sys import stdin
import math
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase
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')
alphabets = list('abcdefghijklmnopqrstuvwxyz')
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieveForSmallestPrimeFactor():
	MAXN = 100001
	spf = [0 for i in range(MAXN)]
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, math.ceil(math.sqrt(MAXN))):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
	return spf

def getPrimeFactorizationLOGN(x):
	spf = sieveForSmallestPrimeFactor()
	ret = list()
	while x != 1:
		ret.append(spf[x])
		x = x // spf[x]
	return ret

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

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

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')

def solve():
	(r, x, y, xi, yi) = li()
	d = (x - xi) ** 2 + (y - yi) ** 2
	d = pow(d, 0.5)
	ans = divideCeil(d, 2 * r)
	print(int(ans))
t = 1
for _ in range(t):
	solve()


import math
x = list(map(int, input().split()))
r = x[0]
distance = math.sqrt((x[4] - x[2]) ** 2 + (x[3] - x[1]) ** 2)
if distance % (2 * r) == 0:
	print(int(distance // (2 * r)))
else:
	print(int(distance // (2 * r)) + 1)


import math
(r, x, y, x_, y_) = map(int, input().split())
step = 0
dist = math.sqrt((x - x_) ** 2 + (y - y_) ** 2)
while dist >= 2 * r:
	dist = dist - 2 * r
	step = step + 1
if dist > 0 and dist < 2 * r:
	step = step + 1
print(step)


from math import ceil
(r, x0, y0, x1, y1) = map(int, input().split())
dist = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
print(ceil(dist / (2 * r)))


import math
(r, x1, y1, x2, y2) = map(int, input().strip().split(' '))
distancia = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2))
diametro = r * 2
dTangente = distancia - diametro
resp = dTangente // diametro
if dTangente % diametro == 0:
	resp += 1
	print(str(int(resp)))
else:
	resp += 2
	print(str(int(resp)))


import math
lst = input().split()
r = int(lst[0])
x = int(lst[1])
y = int(lst[2])
newx = int(lst[3])
newy = int(lst[4])
ans = math.ceil(math.sqrt(pow(newx - x, 2) + pow(newy - y, 2)) / (2 * r))
print(ans)


import math
(r, x, y, x1, y1) = map(int, input().split())
dist = ((x1 - x) ** 2 + (y1 - y) ** 2) ** (1 / 2)
ans = math.ceil(dist / (2 * r))
print(ans)


from math import sqrt, pow, ceil
from decimal import *
l1 = input().split()
l1 = [int(i) for i in l1]
d = sqrt(pow(l1[3] - l1[1], 2) + pow(l1[4] - l1[2], 2))
print(ceil(d / l1[0] / 2))


from math import sqrt
(r, x, y, x1, y1) = map(int, input().split())
if x == x1 and y == y1:
	print(0)
else:
	a = (x - x1) ** 2
	b = (y - y1) ** 2
	c = sqrt(a + b)
	if c <= 2 * r:
		print(1)
	else:
		d = c - r
		s = d / (2 * r)
		if d - int(s) * 2 * r <= r:
			print(int(s) + 1)
		else:
			print(int(s) + 2)


import math
(r, x, y, xn, yn) = map(int, input().split(' '))
dis = pow((x - xn) * (x - xn) + (y - yn) * (y - yn), 0.5)
if dis == 0.0:
	print(0)
else:
	print(math.ceil(dis / (2 * r)))


from collections import defaultdict, deque, Counter, OrderedDict
import math

def main():
	(r, a, b, x, y) = [int(i) for i in input().split()]
	dist = (float(x - a) ** 2 + float(y - b) ** 2) ** 0.5
	ans = math.ceil(dist / (2 * r))
	print(ans)
main()


(z, zz) = (input, lambda : list(map(int, z().split())))
fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
(r, x, y, n, m) = zz()
t = ceil(((x - n) ** 2 + (y - m) ** 2) ** 0.5)
print(ceil(t / (2 * r)))


import math
(r, x, y, xt, yt) = map(int, input().split())
d = 2 * r
dt = math.sqrt((x - xt) ** 2 + (y - yt) ** 2)
print(math.ceil(dt / d))


import math
st = [int(i) for i in input().split(' ')]
r = st[0]
x = st[1]
y = st[2]
x1 = st[3]
y1 = st[4]
d = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
print(math.ceil(d / (2 * r)))


def main():
	(r, x1, y1, x2, y2) = read()
	dist = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
	import math
	return math.ceil(dist / 2 / r)

def read(mode=2):
	inputs = input().strip()
	if mode == 0:
		return inputs
	if mode == 1:
		return inputs.split()
	if mode == 2:
		return list(map(int, inputs.split()))

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='')
write(main())