Mr. Scrooge, a very busy man, decided to count the time he wastes on all sorts of useless stuff to evaluate the lost profit. He has already counted the time he wastes sleeping and eating. And now Mr. Scrooge wants to count the time he has wasted signing papers.

Mr. Scrooge's signature can be represented as a polyline A1A2... An. Scrooge signs like that: first it places a pen at the point A1, then draws a segment from point A1 to point A2, then he draws a segment from point A2 to point A3 and so on to point An, where he stops signing and takes the pen off the paper. At that the resulting line can intersect with itself and partially repeat itself but Scrooge pays no attention to it and never changes his signing style. As Scrooge makes the signature, he never takes the pen off the paper and his writing speed is constant — 50 millimeters per second.

Scrooge signed exactly k papers throughout his life and all those signatures look the same.

Find the total time Scrooge wasted signing the papers.

Input

The first line contains two integers n and k (2 ≤ n ≤ 100, 1 ≤ k ≤ 1000). Each of the following n lines contains the coordinates of the polyline's endpoints. The i-th one contains coordinates of the point Ai — integers xi and yi, separated by a space.

All points Ai are different. The absolute value of all coordinates does not exceed 20. The coordinates are measured in millimeters.

Output

Print one real number — the total time Scrooges wastes on signing the papers in seconds. The absolute or relative error should not exceed 10 - 6.

Examples

Input

2 1
0 0
10 0


Output

0.200000000

Input

5 10
3 1
-5 6
-2 -1
3 2
10 0


Output

6.032163204

Input

6 10
5 0
4 0
6 0
3 0
7 0
2 0


Output

3.000000000

Difficulty: EASY
Tags: Geometry

Starter code:

Solutions:
(n, k) = list(map(int, input().split()))
ans = 0
for i in range(n):
	if i == 0:
		(x, y) = list(map(int, input().split()))
	else:
		(X, Y) = list(map(int, input().split()))
		d = ((X - x) ** 2 + (Y - y) ** 2) ** (1 / 2)
		(x, y) = (X, Y)
		ans += d
ans = ans * k / 50
print('%.9f' % ans)


def euD(x1, y1, x2, y2):
	d = abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2
	d = d ** (1 / 2)
	return d
(N, K) = map(int, input().split())
(x0, y0) = (None, None)
d = 0
for n in range(N):
	(x, y) = map(int, input().split())
	if x0 != None:
		d += euD(x0, y0, x, y)
	(x0, y0) = (x, y)
print(d * K / 50)


from math import sqrt
(n, k) = map(int, input().split())
a = []
(x, y) = map(int, input().split())
a.append([x, y])
d = 0
for i in range(1, n):
	(x, y) = map(int, input().split())
	a.append([x, y])
	d += sqrt((x - a[i - 1][0]) ** 2 + (y - a[i - 1][1]) ** 2)
print('%.6f' % (d * k / 50))


import math

def xxx(x, y):
	z = math.sqrt(x ** 2 + y ** 2)
	return z
(x, y) = [int(i) for i in input().split()]
(a, b) = [int(i) for i in input().split()]
c = 0
for i in range(x - 1):
	z = [int(i) for i in input().split()]
	c += xxx(abs(a - z[0]), abs(b - z[1]))
	(a, b) = (z[0], z[1])
print(c * y / 50)


from math import sqrt
(n, k) = map(int, input().split())
(a, b) = map(int, input().split())
s = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	s += sqrt((x - a) ** 2 + (y - b) ** 2)
	(a, b) = (x, y)
print(s * k / 50)


import math
(t, l) = (0, [])
(n, p) = map(int, input().split(' '))
for i in range(n):
	(x, y) = map(int, input().split(' '))
	l.append([x, y])
for i in range(1, n):
	x = l[i][0] - l[i - 1][0]
	y = l[i][1] - l[i - 1][1]
	t += math.sqrt(x ** 2 + y ** 2)
print(t / 50 * p)


import math
(n, k) = map(int, input().split())
crds = [tuple(map(int, input().split())) for _ in range(n)]
leng = sum([math.hypot(crds[i][0] - crds[i - 1][0], crds[i][1] - crds[i - 1][1]) for i in range(1, n)])
print(leng * k / 50)


import math

def Citire():
	return (int(x) for x in input().split())

def Dist():
	a = 1.0 * (x - x1) * (x - x1)
	b = 1.0 * (y - y1) * (y - y1)
	return math.sqrt(a + b)
(n, k) = Citire()
n = int(n)
(x, y) = Citire()
d = 0.0
for i in range(n - 1):
	(x1, y1) = Citire()
	d += Dist()
	x = x1
	y = y1
d *= k / 50
print(round(d, 9))


(n, k) = map(int, input().split())
distance = 0
(x, y) = map(int, input().split())
for i in range(n - 1):
	(a, b) = map(int, input().split())
	distance += ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	(x, y) = (a, b)
total = k * distance
print('%.9f' % (total / 50))


import math
(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
length = 0
for i in range(n - 1):
	(c, d) = map(int, input().split())
	length += math.sqrt((c - x) ** 2 + (d - y) ** 2)
	x = c
	y = d
print(length / 50 * k)


(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
s = 0
for i in range(n - 1):
	(x1, y1) = map(int, input().split())
	s += ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
	(x, y) = (x1, y1)
print(s * k / 50)


(n, k) = map(int, input().split())
dl = 0
(x, y) = map(int, input().split())
for i in range(n - 1):
	(a, b) = map(int, input().split())
	if a == x:
		dl += abs(b - y)
	elif b == y:
		dl += abs(a - x)
	else:
		dl += (abs(a - x) ** 2 + abs(b - y) ** 2) ** 0.5
	(x, y) = (a, b)
print(dl * k / 50)


(n, k) = input().split()
(prevX, prevY) = input().split()
(prevX, prevY) = (float(prevX), float(prevY))
dist = float(0)
from math import sqrt
for i in range(1, int(n)):
	(newX, newY) = input().split()
	(newY, newX) = (float(newY), float(newX))
	dist += sqrt((newX - prevX) ** 2 + (newY - prevY) ** 2)
	prevX = newX
	prevY = newY
dist *= float(k)
dist /= 50
print(dist)


import math
(n, k) = map(int, input().split())
total_dist = 0
(x, y) = map(int, input().split())
for _ in range(n - 1):
	(a, b) = map(int, input().split())
	total_dist += math.sqrt(pow(x - a, 2) + pow(y - b, 2))
	x = a
	y = b
print(total_dist * (k / 50))


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)
(n, k) = M()
a = 0
(c, d) = M()
for i in range(1, n):
	(x, y) = M()
	a += dist(x, y, c, d)
	c = x
	d = y
s = k * a / 50
print(round(s, 9))


n_k = list(map(int, input().split()))
n = n_k[0]
k = n_k[1]
length = 0
last_point = list(map(int, input().split()))
for i in range(n - 1):
	this_point = list(map(int, input().split()))
	length += ((last_point[0] - this_point[0]) ** 2 + (last_point[1] - this_point[1]) ** 2) ** 0.5
	last_point = this_point
time = length / 50
print(time * k)


import math
(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
m = 0
for i in range(n - 1):
	e = x
	z = y
	(x, y) = map(int, input().split())
	r = abs(x - e)
	t = abs(y - z)
	c = math.sqrt(pow(r, 2) + pow(t, 2))
	c = c + m
	m = c
w = c * k / 50
print('{:.9f}'.format(w))


from math import sqrt
(n, k) = input().split(' ')
(n, k) = (int(n), int(k))
(x, y) = (-0.5, -1)
(a, b) = (-1, -1)
time = 0
for i in range(n):
	(a, b) = input().split(' ')
	(a, b) = (int(a), int(b))
	if x != -0.5:
		time += sqrt((x - a) ** 2 + (y - b) ** 2) / 50
	(x, y) = (a, b)
time *= k
print(time)


import math

def distance(a1, a2):
	return math.sqrt((a1[0] - a2[0]) ** 2 + (a1[1] - a2[1]) ** 2)

def solution(n, l, k):
	ans = 0.0
	for i in range(n - 1):
		ans += distance(l[i], l[i + 1])
	return round(ans * k / 50, 6)
(n, k) = [int(x) for x in input().split(' ')]
_list = []
for i in range(n):
	_list.append([int(x) for x in input().split(' ')])
print('{0:.9f}'.format(round(solution(n, _list, k), 9)))


import math
(n, k) = map(int, input().split())
coords = []
for i in range(n):
	coords.append(list(map(int, input().split())))

def dist(coord1, coord2):
	rise = abs(coord2[1] - coord1[1])
	run = abs(coord2[0] - coord1[0])
	return math.sqrt(rise ** 2 + run ** 2)
sigLength = 0
for i in range(n - 1):
	sigLength += dist(coords[i], coords[i + 1])
print(sigLength * k / 50)


(n, k) = map(int, input().split())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
s = 0
for i in range(1, n):
	s += ((a[i][0] - a[i - 1][0]) ** 2 + (a[i][1] - a[i - 1][1]) ** 2) ** 0.5
print(s * k / 50)


import math

def WastedTime(n, k, A):
	dist = 0
	i = 0
	while i < n - 1:
		(x, y) = [int(p) for p in A[i].split()]
		(nextx, nexty) = [int(p) for p in A[i + 1].split()]
		dist += math.sqrt(math.pow(nextx - x, 2) + math.pow(nexty - y, 2))
		i += 1
	return k * dist / 50
(n, k) = [int(p) for p in input().split()]
A = []
i = 0
while i < n:
	A.append(input())
	i += 1
result = WastedTime(n, k, A)
print('{0:.6f}'.format(result))


import math
(n, k) = map(int, input().split())
a = 0
(x, y) = map(int, input().split())
for i in range(n - 1):
	(p, q) = map(int, input().split())
	a += math.sqrt((x - p) * (x - p) + (y - q) * (y - q))
	(x, y) = (p, q)
print(a * k / 50)


import math
(n, k) = map(int, input().split())
length = 0
(x1, y1) = map(int, input().split())
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	length += math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	(x1, y1) = (x2, y2)
length = length * k
print(length / 50)


(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
l = 0
for i in range(n - 1):
	(u, v) = map(int, input().split())
	l += ((x - u) ** 2 + (y - v) ** 2) ** 0.5
	(x, y) = (u, v)
print(k * l / 50)


from math import sqrt
(n, k) = [int(i) for i in input().split()]
res = 0
(x1, y1) = [int(i) for i in input().split()]
for i in range(n - 1):
	(x2, y2) = [int(i) for i in input().split()]
	res += sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	(x1, y1) = (x2, y2)
res = res / 50 * k
print(res)


import math
(n, k) = map(int, input().split())
(x, y) = (0, 0)
sum = 0
for i in range(n):
	(a, b) = map(int, input().split())
	if i == 0:
		sum -= math.sqrt(a ** 2 + b ** 2)
	sum += math.sqrt((a - x) ** 2 + (b - y) ** 2)
	x = a
	y = b
print('{:0.9f}'.format(sum / 50 * k))


import math

class point:

	def __init__(self, s):
		(self.x, self.y) = map(int, s.split())

	def dist(self, b):
		return (self.x - b.x) ** 2 + (self.y - b.y) ** 2
(n, k) = map(int, input().split())
x = point(input())
ans = 0
for i in range(n - 1):
	n = point(input())
	ans += math.sqrt(x.dist(n))
	x = n
print(ans * k / 50)


from math import sqrt
(n, k) = map(int, input().split())
xy = []
d = 0
while n:
	(x, y) = map(int, input().split())
	xy.append([x, y])
	n -= 1
for i in range(len(xy) - 1):
	(x1, y1) = (xy[i][0], xy[i][1])
	(x2, y2) = (xy[i + 1][0], xy[i + 1][1])
	d += sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2)
td = d * k
print(format(td / 50, '.9f'))


(n, k) = map(int, input().split())
l = [[int(i) for i in input().split()] for i in range(n)]

def Dist(x1, y1, x2, y2):
	return round(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5, 6)
m = []
for i in range(1, n):
	m.append(Dist(l[i - 1][0], l[i - 1][1], l[i][0], l[i][1]))
print(sum(m) * k / 50)


(n, k) = map(int, input().split())
ans = 0
(a, b) = map(int, input().split())
n -= 1
while n:
	n -= 1
	(x, y) = map(int, input().split())
	ans += ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	(a, b) = (x, y)
print(ans / 50 * k)


import math
(n, k) = map(int, input().split())
x = []
y = []
for i in range(0, n):
	(a, b) = map(float, input().split())
	x.append(a)
	y.append(b)
ans = 0.0
for i in range(0, n - 1):
	ans += math.sqrt((x[i + 1] - x[i]) * (x[i + 1] - x[i]) + (y[i + 1] - y[i]) * (y[i + 1] - y[i]))
ans = ans * k / 50
print(ans)


(n, k) = map(int, input().split())
d = 0.0
(x0, y0) = map(int, input().split())
for _ in range(n - 1):
	(x1, y1) = map(int, input().split())
	d += ((x0 - x1) ** 2 + (y0 - y1) ** 2) ** 0.5
	(x0, y0) = (x1, y1)
print(d / 50 * k)


import math

class Point:

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

	def getX(self):
		return self.x

	def getY(self):
		return self.y

	def distanceToPoint(self, otherPoint):
		dx = math.fabs(self.x - otherPoint.getX())
		dy = math.fabs(self.y - otherPoint.getY())
		return math.hypot(dx, dy)
(lines, cant) = list(map(int, input().split(' ')))
distance = 0
for i in range(lines):
	(x, y) = list(map(int, input().split(' ')))
	if i == 0:
		ant = Point(x, y)
	else:
		newPoint = Point(x, y)
		distance += ant.distanceToPoint(newPoint)
		ant = newPoint
seconds = distance * cant / 50
print(str('%.9f' % seconds))


from math import sqrt
(n, k) = map(int, input().split())
(x1, y1) = map(int, input().split())
v = 50.0
x = 0
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	x += sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	(x1, y1) = (x2, y2)
res = x * k / v
print(round(res, 9))


import sys
import math

def readlines(type=int):
	return list(map(type, sys.stdin.readline().split()))

def read(type=int):
	return type(sys.stdin.readline().strip())
joint = lambda it, sep=' ': sep.join([str(i) if type(i) != list else sep.join(map(str, i)) for i in it])

def solve(k, points):

	def getDistance(x1, y1, x2, y2):
		return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	tot_dist = 0
	for i in range(len(points) - 1):
		tot_dist += getDistance(*points[i], *points[i + 1])
	return '{:.9f}'.format(k * tot_dist / 50)

def main():
	(n, k) = readlines()
	points = [readlines() for _ in range(n)]
	print(solve(k, points))
main()


import math

def eud(p1, p2):
	return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
(n, k) = map(int, input().split())
p1 = list(map(int, input().split()))
d = 0
for i in range(1, n):
	tmp = list(map(int, input().split()))
	d += eud(tmp, p1)
	p1 = tmp
print(d * k / 50)


(n, k) = map(int, input().split())
(x1, y1) = map(int, input().split())
t = 0
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	t += ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
	x1 = x2
	y1 = y2
print(t * k / 50)


line = input('').split()
tekrar = int(line[1])
konum = []
for _ in range(int(line[0])):
	a = input('').split()
	konum.append((int(a[0]), int(a[1])))
distance = 0
counter = 0
while counter < len(konum) - 1:
	x = konum[counter][0] - konum[counter + 1][0]
	y = konum[counter][1] - konum[counter + 1][1]
	distance += (x ** 2 + y ** 2) ** (1 / 2)
	counter += 1
print(distance * tekrar / 50)


import math as m
S = []
d = 0
[n, k] = [int(x) for x in input().split()]
for i in range(n):
	S.append([int(x) for x in input().split()])
for j in range(n - 1):
	d += m.sqrt((S[j][0] - S[j + 1][0]) ** 2 + (S[j][1] - S[j + 1][1]) ** 2)
print(d * k / 50)


(n, k) = map(int, input().split())
(px, py) = map(int, input().split())
ans = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	ans += ((px - x) ** 2 + (py - y) ** 2) ** 0.5
	(px, py) = (x, y)
print(ans * (k / 50))


import math
(pts, no) = input().split()
pts = int(pts)
no = int(no)
(x, y) = input().split()
x = int(x)
y = int(y)
dist = 0
for i in range(pts - 1):
	(x1, y1) = input().split()
	x1 = int(x1)
	y1 = int(y1)
	dist += math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1))
	x = x1
	y = y1
print(dist * no / 50)


d = lambda x, y: ((x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2) ** 0.5
(n, k) = map(int, input().split())
a = [[int(i) for i in input().split()] for _ in range(n)]
print(sum((d(a[i], a[i + 1]) for i in range(n - 1))) * k / 50)


import math

def main():
	(n, k) = map(int, input().split())
	ls = []
	d = 0
	co = list(map(int, input().split()))
	for i in range(n - 1):
		temp = list(map(int, input().split()))
		d += math.sqrt(abs(co[0] - temp[0]) ** 2 + abs(co[1] - temp[1]) ** 2)
		co = temp
	print('{0:.9f}'.format(d / 50 * k))
main()


import sys
import math
(n, k) = map(int, input().split())
mul = []
wed = float(0)
for i in range(n):
	(a, b) = map(int, input().split())
	mul.append((a, b))
	if i > 0:
		xa = float(abs(mul[i - 1][0] - a) ** 2)
		xb = float(abs(mul[i - 1][1] - b) ** 2)
		wed += float(pow(xa + xb, float(0.5)))
spd = float(wed / float(50)) * float(k)
print('%.9f' % spd)


(n, k) = map(int, input().split())
(a, b) = map(int, input().split())
l = 0
for _ in range(1, n):
	(x, y) = map(int, input().split())
	l += ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	(a, b) = (x, y)
print(l * k / 50)


(n, k) = map(int, input().split())
answer = {'distance': 0, 'coordinates': list(map(int, input().split()))}
for i in range(n - 1):
	(x, y) = map(int, input().split())
	answer['distance'] += ((answer['coordinates'][0] - x) ** 2 + (answer['coordinates'][1] - y) ** 2) ** 0.5
	answer['coordinates'] = [x, y]
print('%.6f' % (k * answer['distance'] / 50))


def dist(x, y, x2, y2):
	return ((x - x2) ** 2 + (y - y2) ** 2) ** 0.5
(n, k) = map(int, input().split())
ai = [list(map(int, input().split())) for i in range(n)]
ans = [dist(ai[i][0], ai[i][1], ai[i + 1][0], ai[i + 1][1]) for i in range(n - 1)]
print(sum(ans) * k / 50)


from math import hypot, fsum

def main():
	(n, k) = map(int, input().split())
	l = []
	(x, y) = map(int, input().split())
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		x -= a
		y -= b
		l.append(hypot(x, y))
		(x, y) = (a, b)
	print('{:1.9f}'.format(fsum(l) * k / 50))
main()


from math import sqrt

def distance(x1, y1, x2, y2):
	return sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
(n, k) = map(int, input().split())
li = []
for i in range(n):
	li.append(list(map(int, input().split())))
res = 0
for i in range(1, n):
	res += distance(li[i][0], li[i][1], li[i - 1][0], li[i - 1][1]) / 50
print(res * k)


import math
(n, k) = map(int, input().split())
ans = 0
arr = []
for ii in range(n):
	(x, y) = map(int, input().split())
	arr.append([x, y])
for i in range(n - 1):
	xx = arr[i][0] - arr[i + 1][0]
	yy = arr[i][1] - arr[i + 1][1]
	temp = xx ** 2 + yy ** 2
	ans += temp ** 0.5
print(k * ans / 50)


(n, k) = map(int, input().split())
current = list(map(int, input().split()))
total = 0
for i in range(n - 1):
	next1 = list(map(int, input().split()))
	r = (next1[0] - current[0]) ** 2 + (next1[1] - current[1]) ** 2
	r = r ** 0.5
	total += r
	current = next1[:]
print(total / 50 * k)


import math as ma
s = input()
s = s.split(' ')
n = int(s[0])
k = int(s[1])
s = input()
s = s.split(' ')
xp = int(s[0])
yp = int(s[1])
d = 0
for _ in range(n - 1):
	s = input()
	s = s.split(' ')
	xa = int(s[0])
	ya = int(s[1])
	d = d + ma.sqrt((xp - xa) ** 2 + (yp - ya) ** 2)
	xp = xa
	yp = ya
print(d / 50 * k)


from sys import stdin, stdout
import math
from fractions import gcd

def sin():
	return stdin.readline().rstrip()

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
(n, k) = listInput()
d = 0.0
pts = []
for i in range(n):
	pts.append(listInput())
for i in range(1, n):
	d += math.sqrt((pts[i][0] - pts[i - 1][0]) ** 2 + (pts[i][1] - pts[i - 1][1]) ** 2)
print(d * k / 50)


import sys
import math
(n, k) = map(int, input().split())
(a, b) = map(int, input().split())
x = a + b * 1j
L = 0.0
for i in range(1, n):
	(a, b) = map(int, input().split())
	y = a + b * 1j
	L += abs(y - x)
	x = y
print(k * L / 50)


import math
(n, k) = map(int, input().split())
x = []
y = []
for _ in range(n):
	(a, b) = map(int, input().split())
	x.append(a)
	y.append(b)
tot = 0
for i in range(1, n):
	dis = (x[i] - x[i - 1]) ** 2 + (y[i] - y[i - 1]) ** 2
	dis = math.sqrt(dis)
	tot += dis
print(tot * k / 50)


(n, k) = map(int, input().split())
coords = []
for _ in range(n):
	(x, y) = map(int, input().split())
	coords.append((x, y))
(px, py) = coords[0]
space = 0
for i in range(1, n):
	(cx, cy) = coords[i]
	dist = ((cx - px) * (cx - px) + (cy - py) * (cy - py)) ** 0.5
	space += dist
	(px, py) = (cx, cy)
ans = space * k / 50
print(ans)


import math
(n, k) = list(map(int, input().split()))
v = 50
dist = 0
lasx = 0
lasy = 0
inid = 0
for item in range(1):
	(x, y) = list(map(int, input().split()))
	inid = math.sqrt((x - lasx) ** 2 + (y - lasy) ** 2)
	lasx = x
	lasy = y
for item in range(n - 1):
	(x, y) = list(map(int, input().split()))
	dist = dist + math.sqrt((x - lasx) ** 2 + (y - lasy) ** 2)
	lasx = x
	lasy = y
time_taken = k * dist / v
print(time_taken)


from math import sqrt
(n, k) = list(map(int, input().split(' ')))
(a, b) = list(map(int, input().split(' ')))
sum = 0
for i in range(1, n):
	x = list(map(int, input().split(' ')))
	sum += sqrt((a - x[0]) ** 2 + (b - x[1]) ** 2)
	(a, b) = (x[0], x[1])
print(k * sum / 50)


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')
from collections import defaultdict
from math import ceil, floor, sqrt, log2, gcd
from heapq import heappush, heappop
from bisect import bisect_left, bisect
import sys
abc = 'abcdefghijklmnopqrstuvwxyz'
ABC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
(n, k) = map(int, input().split())
dist = 0
(a, b) = map(int, input().split())
for _ in range(n - 1):
	(a_, b_) = map(int, input().split())
	dist += sqrt((a_ - a) ** 2 + (b_ - b) ** 2)
	(a, b) = (a_, b_)
print(k * dist / 50)


import bisect
from itertools import accumulate
import os
import sys
import math
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split())
ans = 0
dis = 0
(x, y) = map(int, input().split())
for i in range(n - 1):
	(a, b) = map(int, input().split())
	dis += math.sqrt((x - a) ** 2 + (y - b) ** 2)
	x = a
	y = b
print(dis * k / 50)


(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
dist = 0
for _ in range(n - 1):
	(x1, y1) = map(int, input().split())
	temp = ((x1 - x) ** 2 + (y1 - y) ** 2) ** (1 / 2)
	dist = dist + temp
	(x, y) = (x1, y1)
print(k * dist / 50)


from math import sqrt

def distance(x1, y1, x2, y2):
	xdis = (x1 - x2) ** 2
	ydis = (y1 - y2) ** 2
	dis = sqrt(xdis + ydis)
	return dis
(n, k) = map(int, input().split())
points = []
tot = 0
for i in range(n):
	(x, y) = map(int, input().split())
	points.append((x, y))
for j in range(len(points) - 1):
	tot += distance(points[j][0], points[j][1], points[j + 1][0], points[j + 1][1])
est = tot / 50
waste = est * k
print('%.9f' % waste)


import sys
from functools import reduce
from collections import Counter
import time
import datetime
from math import sqrt, gcd

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

def sip():
	return sys.stdin.readline()

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

def mips():
	return map(str, sys.stdin.readline().split())

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

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.insert(i, arr)
	return lst

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

def minJumps(arr, n):
	jumps = [0 for i in range(n)]
	if n == 0 or arr[0] == 0:
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if i <= j + arr[j] and jumps[j] != float('inf'):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n - 1]

def dic(arr):
	return Counter(arr)

def check_prime(n):
	if n < 2:
		return False
	for i in range(2, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True
(n, k) = mip()
lst = []
dist = 0
while n:
	n -= 1
	(x, y) = mip()
	if lst != []:
		p = lst[-1]
		dist += ((p[0] - x) ** 2 + (p[1] - y) ** 2) ** 0.5
	lst.append([x, y])
print('%0.9f' % (dist / 50 * k))


things = [*map(int, input().split())]
distance = 0
prev_point = [*map(int, input().split())]
for _ in range(0, things[0] - 1):
	new_point = [*map(int, input().split())]
	distance += ((new_point[0] - prev_point[0]) ** 2 + (new_point[1] - prev_point[1]) ** 2) ** 0.5
	prev_point = new_point
print(distance / 50.0 * things[1])


def Dist(P1, P2):
	return pow((P2[1] - P1[1]) ** 2 + (P2[0] - P1[0]) ** 2, 1 / 2)
(n, k) = map(int, input().split())
Points = []
for i in range(n):
	(x, y) = map(int, input().split())
	Points.append((x, y))
D = 0
for i in range(1, n):
	D += Dist(Points[i], Points[i - 1])
D *= k
ans = D / 50
print(ans)


import math
(n, k) = [int(i) for i in input().split()]
total = 0
list1 = []
for x in range(n):
	(x1, y1) = [int(i) for i in input().split()]
	if x == 0:
		list1.append([x1, y1])
		continue
	total += math.sqrt((list1[-1][0] - x1) ** 2 + (list1[-1][1] - y1) ** 2)
	list1.append([x1, y1])
print(total * k / 50)


(n, k) = map(int, input().split())
(nowx, nowy) = map(int, input().split())
ans = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	ans += ((nowx - x) * (nowx - x) + (nowy - y) * (nowy - y)) ** 0.5
	(nowx, nowy) = (x, y)
print(ans * k / 50)


import os
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from io import BytesIO, IOBase
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

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

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

def instr():
	s = input()
	return list(s[:len(s)])

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

def main():
	(n, k) = invr()
	(x1, y1) = invr()
	d = 0
	for _ in range(n - 1):
		(x2, y2) = invr()
		d += sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2))
		(x1, y1) = (x2, y2)
	d *= k
	res = d / 50
	print(res)
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')
main()


def distance(x1, y1, x2, y2):
	return pow(pow(x2 - x1, 2) + pow(y2 - y1, 2), 0.5)

class coord:

	def __init__(self, x, y):
		self.x = x
		self.y = y
(n, k) = [int(i) for i in input().split()]
coordinates = []
for i in range(n):
	(x, y) = [int(j) for j in input().split()]
	coordinates.append(coord(x, y))
amount_of_time = 0
for i in range(n - 1):
	dist = distance(coordinates[i].x, coordinates[i].y, coordinates[i + 1].x, coordinates[i + 1].y)
	amount_of_time += dist / 50
amount_of_time *= k
print(amount_of_time)


(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
s = 0
for i in range(n - 1):
	(xx, yy) = map(int, input().split())
	s += ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5 / 50
	(x, y) = (xx, yy)
print(s * k)


import string
import math

def main_function():
	(n, k) = [int(i) for i in input().split(' ')]
	signature = [[int(i) for i in input().split(' ')] for j in range(n)]
	starting_point = signature[0]
	length = 0
	for i in range(1, len(signature)):
		length += math.sqrt((signature[i][0] - starting_point[0]) ** 2 + (signature[i][1] - starting_point[1]) ** 2)
		starting_point = signature[i]
	return k * (length / 50)
print(main_function())


import math
(n, k) = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(n)]
ans = 0
for i in range(len(a) - 1):
	ans += math.sqrt((a[i][0] - a[i + 1][0]) ** 2 + (a[i][1] - a[i + 1][1]) ** 2)
print(ans / 50 * k)


a = list(map(int, input().split()))
b = []
for i in range(a[0]):
	b += [list(map(int, input().split()))]
print(a[1] * sum(map(lambda x: ((b[x][0] - b[x + 1][0]) ** 2 + (b[x][1] - b[x + 1][1]) ** 2) ** 0.5, range(len(b) - 1))) / 50)


import math
(n, k) = [int(x) for x in input().split(' ')]
points = []
t = 0
for i in range(n):
	points.append([int(x) for x in input().split(' ')])
for i in range(n - 1):
	t += math.sqrt((points[i][0] - points[i + 1][0]) ** 2 + (points[i][1] - points[i + 1][1]) ** 2)
print(k * t / 50)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x) + '\n')
(n, k) = get_int_list()
(x, y) = get_int_list()
d = 0
for i in range(n - 1):
	(x1, y1) = get_int_list()
	d += math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	(x, y) = (x1, y1)
d = d * k
print('{0:.9f}'.format(d / 50))


import math
(n, k) = map(int, input().split())
r = 0
l = [[] for i in range(n)]
for i in range(n):
	(x, y) = map(int, input().split())
	l[i].append(x)
	l[i].append(y)
for i in range(n - 1):
	r += math.sqrt(pow(l[i + 1][0] - l[i][0], 2) + pow(l[i + 1][1] - l[i][1], 2))
r *= k
print(r / 50)


import math

def dist(x0, y0, x1, y1):
	return math.sqrt(math.pow(x1 - x0, 2) + math.pow(y1 - y0, 2))
tmp = input().split()
(n, k) = (int(tmp[0]), float(tmp[1]))
list_l = []
tmp = input().split()
list_l.append((float(tmp[0]), float(tmp[1])))
dist_sum = 0
for i in range(1, n):
	tmp = input().split()
	list_l.append((float(tmp[0]), float(tmp[1])))
	dist_sum += dist(list_l[i - 1][0], list_l[i - 1][1], list_l[i][0], list_l[i][1])
dist_sum /= 50
dist_sum *= k
print(dist_sum)


import math

def length(signature):
	s = 0
	for (A0, A1) in zip(signature, signature[1:]):
		(x0, y0) = A0
		(x1, y1) = A1
		s += math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2)
	return s

def solve():
	(n, k) = map(int, input().split())
	signature = []
	for _ in range(n):
		(x, y) = map(int, input().split())
		signature.append((x, y))
	length_signature = length(signature)
	total = length_signature * k
	time = total / 50.0
	print('{:.9f}'.format(time))
solve()


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

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)]

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)

def dist(x1, y1, x2, y2):
	return sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
(n, k) = isp()
s = 0
p = []
for _ in range(n):
	(x, y) = isp()
	p.append(pair(x, y))
for i in range(1, n):
	s += dist(p[i].fi, p[i].se, p[i - 1].fi, p[i - 1].se)
s *= k
print(s / 50)


(n, k) = [int(value) for value in input().split()]
points = []
distance = 0
for i in range(n):
	(x, y) = input().split()
	points.append([int(x), int(y)])
for i in range(0, n - 1):
	distance += ((points[i + 1][0] - points[i][0]) ** 2 + (points[i + 1][1] - points[i][1]) ** 2) ** 0.5
print(distance * k / 50)


import math
(n, k) = [int(i) for i in input().split()]
(x, y) = [int(i) for i in input().split()]
dis = 0
for i in range(n - 1):
	(xx, yy) = [int(i) for i in input().split()]
	dis += math.sqrt(pow(x - xx, 2) + pow(y - yy, 2))
	(x, y) = (xx, yy)
print(dis / 50 * k)


import math

def Citire():
	l = input()
	a = b = 0
	aux = 0
	semn = 1
	for i in l:
		if i.isnumeric():
			aux = aux * 10 + int(i)
		elif i == '-':
			semn *= -1
		else:
			a = semn * aux
			semn = 1
			aux = 0
	b = semn * aux
	return (1.0 * a, 1.0 * b)

def Dist():
	a = 1.0 * (x - x1) * (x - x1)
	b = 1.0 * (y - y1) * (y - y1)
	return math.sqrt(a + b)
(n, k) = Citire()
n = int(n)
(x, y) = Citire()
d = 0.0
for i in range(n - 1):
	(x1, y1) = Citire()
	d += Dist()
	x = x1
	y = y1
d *= k / 50
print(round(d, 9))


from math import hypot
(n, k) = input().split(' ')
(x, y) = input().split(' ')
prevX = int(x)
prevY = int(y)
ans = 0
for _ in range(int(n) - 1):
	(x, y) = input().split(' ')
	ans += hypot(prevX - int(x), prevY - int(y))
	prevX = int(x)
	prevY = int(y)
print(ans * int(k) / 50)


import math
(n, l) = list(map(int, input().split()))
p = []
for k in range(n):
	p.append(list(map(int, input().split())))
s = 0
for i in range(1, n):
	s += math.sqrt(abs(p[i - 1][0] - p[i][0]) ** 2 + abs(p[i - 1][1] - p[i][1]) ** 2)
print(s * l / 50)


import math

def dist(xa, ya, xb, yb):
	return math.sqrt((xa - xb) ** 2 + (ya - yb) ** 2)
a = list(map(int, input().split()))
n = a[0]
k = a[1]
tmp = []
for _ in range(n):
	tmp.append(list(map(int, input().split())))
d = 0
for i in range(n - 1):
	d += dist(tmp[i][0], tmp[i][1], tmp[i + 1][0], tmp[i + 1][1])
print('{:.9f}'.format(d * k / 50))


from math import sqrt
dist = lambda p1, p2: sqrt(sum([(p1[i] - p2[i]) ** 2 for i in range(len(p1))]))
(n, k) = list(map(int, input().split()))
ps = [list(map(int, input().split())) for _ in range(n)]
print(0.02 * k * sum([dist(ps[i], ps[i + 1]) for i in range(n - 1)]))


from math import hypot
I = lambda : map(int, input().split())
(n, k) = I()
A = [tuple(I()) for _ in range(n)]
print(sum((hypot(x1 - x2, y1 - y2) for ((x1, y1), (x2, y2)) in zip(A, A[1:]))) * k / 50)


(n, k) = (int(x) for x in input().split())
dots = []
res = 0
for i in range(n):
	dots.append(tuple((int(x) for x in input().split())))
	if i == 0:
		continue
	res += ((dots[i][0] - dots[i - 1][0]) ** 2 + (dots[i][1] - dots[i - 1][1]) ** 2) ** 0.5
print(res * k / 50)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
(nb_points, ktimes) = read_ints()
(x, y) = read_ints()
distance_sum = 0
for i in range(nb_points - 1):
	(x1, y1) = read_ints()
	distance_sum += ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
	(x, y) = (x1, y1)
print('{:.9f}'.format(distance_sum * ktimes / 50))


from math import sqrt
(n, k) = map(int, input().split())
(xPrev, yPrev) = map(int, input().split())
d = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	d += sqrt((x - xPrev) ** 2 + (y - yPrev) ** 2)
	xPrev = x
	yPrev = y
print(d / 50 * k)


import math as m
(n, k) = [int(x) for x in input().split()]
d = []
dist = 0
ans = 0
for i in range(n):
	d.append([int(y) for y in input().split()])
for i in range(n - 1):
	dist += m.sqrt(abs(d[i][0] - d[i + 1][0]) ** 2 + abs(d[i][1] - d[i + 1][1]) ** 2)
ans = dist * k * 0.02
print('{:.9f}'.format(ans))


import math
(n, k) = map(int, input().split())
a = []
total_dist = 0
for i in range(n):
	x = list(map(int, input().split()))
	a.append(x)
for j in range(n - 1):
	total_dist += math.sqrt(abs(a[j][0] - a[j + 1][0]) ** 2 + abs(a[j][1] - a[j + 1][1]) ** 2)
print(k * total_dist / 50)


from math import sqrt

def zhadina(a, b, k):
	result = 0
	for i in range(len(a)):
		if i + 1 < len(a):
			result += sqrt((a[i + 1] - a[i]) * (a[i + 1] - a[i]) + (b[i + 1] - b[i]) * (b[i + 1] - b[i])) / 50
	return format(result * k, '.9f')
(n, k) = [int(j) for j in input().split()]
(x, y) = (list(), list())
for z in range(n):
	(s, t) = [int(r) for r in input().split()]
	x.append(s)
	y.append(t)
print(zhadina(x, y, k))


(n, k) = [int(y) for y in input().split()]
dist = 0
(p1, q1) = [int(y) for y in input().split()]
for _ in range(n - 1):
	(p2, q2) = [int(y) for y in input().split()]
	dist += round(((p2 - p1) ** 2 + (q2 - q1) ** 2) ** 0.5, 9)
	(p1, q1) = (p2, q2)
dist *= k
print(round(dist / 50, 9))


from math import sqrt
d = 0
(n, k) = [int(i) for i in input().split()]
(x1, y1) = [int(i) for i in input().split()]
for i in range(n - 1):
	(x2, y2) = [int(i) for i in input().split()]
	d += sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	x1 = x2
	y1 = y2
print('{:0.9f}'.format(d / 50 * k))


import math
(n, k) = map(int, input().split())
A = []
s = 0
(x1, y1) = map(int, input().split())
for i in range(1, n):
	(x, y) = map(int, input().split())
	s += math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
	x1 = x
	y1 = y
s = s * (k / 50)
print('%.9f' % s)


from math import sqrt
(n, k) = map(int, input().split())
h = 0
(x1, y1) = map(int, input().split())
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	h += sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
	(x1, y1) = (x2, y2)
print('{:.7f}'.format(h * k / 50))


from math import sqrt

def Sep(a, b):
	return sqrt(a ** 2 + b ** 2)
(n, k) = map(int, input().split())
(x1, y1) = map(int, input().split())
dist = 0
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	dist += Sep(x2 - x1, y2 - y1)
	(x1, y1) = (x2, y2)
print(dist * k / 50)


import math
split = lambda : map(int, input().split())
(a, b) = split()
n = 0
for x in range(a):
	(s, t) = split()
	if x != 0:
		n += math.sqrt((s - p) ** 2 + (t - q) ** 2)
	(p, q) = (s, t)
n /= 50
print(n * b)


(n, k) = [int(i) for i in input().split()]
(x, y) = [int(j) for j in input().split()]
l = 0
for i in range(n - 1):
	(a, b) = [int(j) for j in input().split()]
	l = l + ((a - x) ** 2 + (b - y) ** 2) ** (1 / 2)
	x = a
	y = b
print(l * k / 50)


def inp():
	return map(int, input().split())
import math as m
(n, k) = inp()
(dis, pre1, pre2) = (0, 0, 0)
for i in range(n):
	(x, y) = inp()
	if i > 0:
		dis += m.sqrt((x - pre1) ** 2 + (y - pre2) ** 2)
	(pre1, pre2) = (x, y)
print('{0:.9f}'.format(dis * k / 50, 9))


from math import *
(n, k) = map(int, input().split())
arr = []
for i in range(n):
	arr.append([])
	arr[i] = [int(z) for z in input().split()]
s = 0
for i in range(1, n):
	s = s + sqrt((arr[i][0] - arr[i - 1][0]) ** 2 + (arr[i][1] - arr[i - 1][1]) ** 2)
print(s / 50 * k)


(n, k) = map(int, input().split())
(s, a, b) = (0, 0, 0)
for i in range(n):
	(c, d) = map(int, input().split())
	s += ((c - a) ** 2 + (b - d) ** 2) ** 0.5
	(a, b) = (c, d)
	if i == 0:
		s = 0
s *= k / 50
print(s)


import sys
import math
(n, k) = [int(x) for x in sys.stdin.readline().split()]
res = 0
(x1, y1) = [int(x) for x in sys.stdin.readline().split()]
for i in range(n - 1):
	(x2, y2) = [int(x) for x in sys.stdin.readline().split()]
	res += math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	(x1, y1) = (x2, y2)
print('{0:.9f}'.format(res * k / 50.0))


import math
(n, k) = map(int, input().split())
v = 50
s = 0
(posx, posy) = map(int, input().split())
for i in range(n - 1):
	(tx, ty) = map(int, input().split())
	s += math.sqrt((posx - tx) ** 2 + (posy - ty) ** 2)
	(posx, posy) = (tx, ty)
print(s * k / v)


from math import sqrt
(n, k) = list(map(int, input().split()))
(preva, prevb) = list(map(int, input().split()))
total = 0.0
for i in range(1, n):
	(cura, curb) = list(map(int, input().split()))
	dista = abs(cura - preva)
	distb = abs(curb - prevb)
	total += sqrt(dista ** 2 + distb ** 2)
	preva = cura
	prevb = curb
print(total * k / 50)


import math
(n, k) = list(map(int, input().split()))
li = [tuple(map(int, input().split())) for i in range(n)]
(i, j, length) = (0, 1, 0)
while j < n:
	(x1, y1) = li[i]
	(x2, y2) = li[j]
	length += math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	i += 1
	j += 1
print('%.9f' % (length / 50 * k))


import sys
import math
input = sys.stdin.readline
(n, k) = map(int, input().strip().split())
a = []
for _ in range(n):
	(x, y) = map(int, input().strip().split())
	a.append([x, y])
ans = 0
for i in range(1, n):
	d = (a[i][0] - a[i - 1][0]) ** 2 + (a[i][1] - a[i - 1][1]) ** 2
	ans += math.sqrt(d) / 50
print('%.12f' % (ans * k))


I = lambda : map(int, input().split())
(n, k) = I()
a = [[*map(int, input().split())] for _ in [0] * n]
r = 0
for (u, v) in zip(a, a[1:]):
	r += ((u[0] - v[0]) ** 2 + (u[1] - v[1]) ** 2) ** 0.5
print(r * k / 50)


import math
(p, s) = map(int, input().split())
d = 0
a = []
for i in range(p):
	(x, y) = map(int, input().split())
	a.append([x, y])
for i in range(p - 1):
	x1 = a[i][0]
	y1 = a[i][1]
	x2 = a[i + 1][0]
	y2 = a[i + 1][1]
	d += math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
	x = d * (s / 50)
print('%.6f' % x)


import math
(n, k) = map(int, input().split(' '))
(x1, y1) = map(float, input().split(' '))
res = 0
for i in range(n - 1):
	(x2, y2) = map(float, input().split(' '))
	res += math.hypot(x1 - x2, y1 - y2)
	(x1, y1) = (x2, y2)
print(res * k / 50.0)


import sys
input = sys.stdin.readline
(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
counter = 0
for i in range(0, n - 1):
	ai = list(map(int, input().split()))
	counter += ((a[0] - ai[0]) ** 2 + (a[1] - ai[1]) ** 2) ** 0.5
	a = ai
counter *= k
print(counter / 50)


from math import hypot
(n, k) = map(int, input().split())
(px, py) = map(int, input().split())
ln = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	ln += hypot(x - px, y - py)
	px = x
	py = y
print(ln * k / 50)


import math
(n, k) = map(int, input().split())
(prev1, prev2) = map(int, input().split())
total = 0
for i in range(1, n):
	(tmp1, tmp2) = map(int, input().split())
	total += math.sqrt((tmp1 - prev1) ** 2 + (tmp2 - prev2) ** 2)
	(prev1, prev2) = (tmp1, tmp2)
print(total * k * 0.02)


def dis(a, b, c, d):
	p = ((a - b) ** 2 + (c - d) ** 2) ** (1 / 2)
	return p
l = []
a = input().split()
n = int(a[0])
k = int(a[1])
for i in range(n):
	q = []
	s = input().split()
	r = int(s[0])
	t = int(s[1])
	q.append(r)
	q.append(t)
	l.append(q)
diss = 0.0
for i in range(1, n):
	y = dis(l[i][0], l[i - 1][0], l[i][1], l[i - 1][1])
	diss = diss + y
diss = diss * k
print(diss / 50)


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 dijkstra(start, distance, path, n):
	visited = [False for _ in range(n)]
	distance[start] = 0
	for i in range(n):
		v = -1
		for j in range(n):
			if not visited[v] and (v == -1 or distance[j] < distance[v]):
				v = j
		if distance[v] == math.inf:
			break
		visited[v] = True
		for edge in adj[v]:
			destination = edge[0]
			weight = edge[1]
			if distance[v] + weight < distance[destination]:
				distance[destination] = distance[v] + weight
				path[destination] = v

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

def main():
	try:
		(n, k) = invr()
		calc = 0
		prev = []
		for i in range(n):
			(x, y) = invr()
			if prev:
				calc += math.sqrt((x - prev[0]) ** 2 + (y - prev[1]) ** 2)
			prev = [x, y]
		print(calc * k / 50)
	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()


import math

def distance(l1, l2):
	(x1, y1) = (l1[0], l1[1])
	(x2, y2) = (l2[0], l2[1])
	d1 = math.pow(x1 - x2, 2)
	d2 = math.pow(y1 - y2, 2)
	return math.sqrt(d1 + d2)
(n, k) = [int(x) for x in input().split()]
initial = [int(x) for x in input().split()]
S = 0
for case in range(n - 1):
	new = [int(x) for x in input().split()]
	S += distance(new, initial)
	initial = new
print(k * S / 50.0)


(n, k) = map(int, input().split())
l = 0
s = []
for a in range(n):
	s.append([int(j) for j in input().split()])

def f(x, y):
	a = (x[0] - y[0]) ** 2
	b = (x[1] - y[1]) ** 2
	return (a + b) ** 0.5
for j in range(n - 1):
	l += f(s[j], s[j + 1])
x = l / 50 * k
print('%.6f' % x)


def dis(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
tot_dis = 0
(n, k) = map(int, input().split())
(curr_x, curr_y) = map(int, input().split())
for i in range(1, n):
	(new_x, new_y) = map(int, input().split())
	tot_dis += dis(curr_x, curr_y, new_x, new_y)
	(curr_x, curr_y) = (new_x, new_y)
time = tot_dis * k / 50
print('%0.9f' % time)


from math import sqrt
(n, k) = map(int, input().split())
l = []
s = 0
for i in range(n):
	(a, b) = map(int, input().split())
	l.append([a, b])
for i in range(n - 1):
	c = sqrt((l[i][0] - l[i + 1][0]) ** 2 + (l[i][1] - l[i + 1][1]) ** 2)
	s += c
s *= k
print('%.9f' % (s / 50))


(n, k) = map(int, input().split())
arr = []
for i in range(n):
	arr.append(list(map(int, input().split())))
length = 0
for i in range(0, len(arr) - 1):
	length += ((arr[i + 1][0] - arr[i][0]) ** 2 + (arr[i + 1][1] - arr[i][1]) ** 2) ** 0.5
print(k * length / 50)


from math import sqrt
(n, k) = map(int, input().split())
ln = 0.0
prev = list(map(int, input().split()))
for i in range(1, n):
	now = list(map(int, input().split()))
	ln += sqrt((now[0] - prev[0]) ** 2 + (now[1] - prev[1]) ** 2)
	prev = now
print(ln / 50 * k)


__author__ = 'Esfandiar'
from math import sqrt
(n, k) = map(int, input().split())
A = list()
for i in range(n):
	A.append(list(map(int, input().split())))
t = 0
v = 50
for i in range(n - 1):
	x = sqrt((A[i][0] - A[i + 1][0]) ** 2 + (A[i][1] - A[i + 1][1]) ** 2)
	t += x / v
print(t * k)


from math import sqrt
[n, k] = list(map(int, input().split()))
s = 0
[xprev, yprev] = list(map(float, input().split()))
for i in range(1, n):
	[x, y] = list(map(float, input().split()))
	s += sqrt((x - xprev) ** 2 + (y - yprev) ** 2)
	xprev = x
	yprev = y
s *= k
s /= 50.0
print(s)


import sys
(n, k) = map(int, sys.stdin.readline().split())
(a, b) = map(int, sys.stdin.readline().split())
x = a + b * 1j
L = 0.0
for i in range(1, n):
	(a, b) = map(int, sys.stdin.readline().split())
	y = a + b * 1j
	L += abs(y - x)
	x = y
print(k * L / 50)


(n, k) = map(int, input().split())
s = 0
(x0, y0) = map(int, input().split())
for i in range(n - 1):
	(x, y) = map(int, input().split())
	s += ((x - x0) ** 2 + (y - y0) ** 2) ** (1 / 2)
	(x0, y0) = (x, y)
print(k * s / 50)


from math import *
(n, k) = map(int, input().split())
pts = []
for _ in range(n):
	(x, y) = map(int, input().split())
	pts.append((x, y))
s = 0
for i in range(n - 1):
	(x, y) = pts[i]
	(u, v) = pts[i + 1]
	s += hypot(x - u, y - v)
print(s * k / 50)


(n, k) = map(int, input().split())
lis = []
while n > 0:
	(x, y) = map(int, input().split())
	lis.append(x)
	lis.append(y)
	n = n - 1
dist = 0.0
i = 0
while i + 3 <= len(lis):
	dist = dist + ((lis[i] - lis[i + 2]) ** 2 + (lis[i + 1] - lis[i + 3]) ** 2) ** 0.5
	i = i + 2
r = dist * k / 50
print(r)


class point:
	x = 0
	y = 0

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

def dist(a, b):
	return ((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y)) ** 0.5
arr = []
(n, k) = list(map(int, input().split()))
for i in range(0, n, 1):
	(a, b) = list(map(int, input().split()))
	p = point(a, b)
	arr.append(p)
dista = 0.0
for i in range(0, n - 1, 1):
	dista += dist(arr[i], arr[i + 1])
print('{0:.8f}'.format(dista * k / 50))


import math
inp = str(input()).split(' ')
n = int(inp[0])
k = int(inp[1])

def pythag(a, b):
	(x1, y1) = a
	(x2, y2) = b
	return math.sqrt(abs(x2 - x1) ** 2 + abs(y2 - y1) ** 2)
values = []
for i in range(n):
	inp = str(input()).split(' ')
	values.append((int(inp[0]), int(inp[1])))
total = 0
for i in range(1, len(values), 1):
	total += pythag(values[i - 1], values[i])
total *= k
total /= 50
print('%.7f' % total)


(n, k) = map(int, input().split())
b = []
for i in range(n):
	a = list(map(int, input().split()))
	b.append(a)

def d(a1, a2):
	return pow(pow(a1[0] - a2[0], 2) + pow(a1[1] - a2[1], 2), 0.5)
ans = 0
for i in range(n - 1):
	ans += d(b[i + 1], b[i])
print(ans * k / 50)


(n, k) = map(int, input().split())
xp = []
yp = []

def dist(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
for i in range(n):
	(x, y) = map(int, input().split())
	xp.append(x)
	yp.append(y)
d = 0
for i in range(n - 1):
	(x1, x2) = (xp[i], xp[i + 1])
	(y1, y2) = (yp[i], yp[i + 1])
	d += dist(x1, y1, x2, y2)
lost = d * k / 50
print(lost)


import math
(n, k) = [int(x) for x in input().split()]
dist = 0
(prevx, prevy) = [int(x) for x in input().split()]
for i in range(1, n):
	(x, y) = [int(x) for x in input().split()]
	dist += math.sqrt(abs(x - prevx) ** 2 + abs(y - prevy) ** 2)
	prevx = x
	prevy = y
print(dist / 50 * k)


(n, k) = map(int, input().strip().split())
r2 = 0
res = []
for i in range(0, n):
	(x, y) = map(int, input().strip().split())
	if i != 0:
		r2 += ((res[-1][0] - x) ** 2 + (res[-1][1] - y) ** 2) ** 0.5
	res.append([x, y])
print(r2 * k * 0.02)


inn = list(map(int, input().split(' ')))
pnts = inn[0]
mult = inn[1]
dist = 0
c = list(map(int, input().split(' ')))
for i in range(1, pnts):
	s = list(map(int, input().split(' ')))
	x1 = c[0]
	x2 = s[0]
	y1 = c[1]
	y2 = s[1]
	dist += ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
	c = s
tt = dist / 50 * mult
print('%.9f' % tt)


from itertools import product
from math import ceil, gcd, sqrt
import string
from decimal import Decimal

def binary_table(string_with_all_characters, length_to_make):
	return [''.join(x) for x in product(string_with_all_characters, repeat=length_to_make)]

def all_possible_substrings(string):
	return [int(string[i:j]) for i in range(len(string)) for j in range(i + 1, len(string) + 1)]

def number_of_substrings(length):
	return int(length * (length + 1) / 2)

def is_prime(num):
	for i in range(2, num):
		if num / i == int(num / i) and num != i:
			return False
	return True
(num_of_lines, multiplier) = map(int, input().split())
start_point = [0, 0]
num_mil = 0
for i in range(num_of_lines):
	(x, y) = map(int, input().split())
	if i == 0:
		start_point = [x, y]
	else:
		num_mil += sqrt((x - start_point[0]) ** 2 + (y - start_point[1]) ** 2)
		start_point = [x, y]
print(Decimal(num_mil * multiplier) / Decimal(50))


from math import sqrt
(n, k) = map(int, input().split())
ans = 0
(x1, y1) = map(int, input().split())
for i in range(n - 1):
	(x, y) = map(int, input().split())
	ans += sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
	(x1, y1) = (x, y)
print(ans * k / 50)


import math
(n, k) = map(int, input().split())
(x, y) = map(int, input().split())
ans = 0
for i in range(n - 1):
	(l, r) = map(int, input().split())
	ans += math.sqrt(abs((l - x) ** 2) + abs((r - y) ** 2))
	(x, y) = (l, r)
print(k * ans / 50)


import math
(n, k) = [int(x) for x in input().split()]
L = []
for _ in range(n):
	(x, y) = [int(x) for x in input().split()]
	L.append((x, y))
ans = 0
for i in range(len(L) - 1):
	ans += math.sqrt((L[i + 1][0] - L[i][0]) ** 2 + (L[i + 1][1] - L[i][1]) ** 2)
print('%.6f' % (ans / 50 * k))


import sys
input = sys.stdin.readline

def len(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
(n, k) = map(int, input().split())
ans = 0
(x1, y1) = map(int, input().split())
for i in range(n - 1):
	(x2, y2) = map(int, input().split())
	ans += len(x1, y1, x2, y2)
	x1 = x2
	y1 = y2
ans = '{0: .9f}'.format(ans * k * 0.02)
print(ans)


(n, k) = map(int, input().split())
ans = 0
(fx, fy) = map(int, input().split())
for i in range(n - 1):
	(x, y) = map(int, input().split())
	ans += ((fx - x) ** 2 + (fy - y) ** 2) ** 0.5 / 50
	(fx, fy) = (x, y)
print(ans * k)


import math

def distance_points(x1, y1, x2, y2):
	distance = (1.0 * (x2 - x1)) ** 2
	distance += (y2 - y1) ** 2
	distance = math.sqrt(distance)
	return distance
(n, k) = map(int, input().split())
distance = 0.0
for i in range(0, n):
	(x, y) = map(int, input().split())
	if i == 0:
		(p_x, p_y) = (x, y)
	else:
		distance += distance_points(x, y, p_x, p_y)
		(p_x, p_y) = (x, y)
time = distance / 50.0
time *= k
print(time)


def dis(x1, y1, x2, y2):
	x = (x1 - x2) ** 2
	y = (y1 - y2) ** 2
	return (x + y) ** 0.5
(n, k) = map(int, input().split())
x = []
y = []
z = []
for i in range(n):
	(a, b) = map(int, input().split())
	x.append(a)
	y.append(b)
	if i > 0:
		z.append(dis(a, b, x[i - 1], y[i - 1]) / 50)
print(sum(z) * k)


(n, k) = map(int, input().split())
(a, b) = map(int, input().split())
n -= 1
dist = 0
for i in range(n):
	(p, q) = map(int, input().split())
	dist += ((p - a) ** 2 + (q - b) ** 2) ** 0.5
	(a, b) = (p, q)
print('{:.10f}'.format(dist * k / 50))


from math import sqrt
l1 = list(map(int, input().split()))
l2 = []
for i in range(l1[0]):
	l = list(map(int, input().split()))
	l2.append(l)
total = 0
for i in range(1, l1[0]):
	total += sqrt((l2[i - 1][0] - l2[i][0]) ** 2 + (l2[i - 1][1] - l2[i][1]) ** 2)
time = total / 50
ttime = time * l1[1]
print(ttime)


(n, k) = map(int, input().split())
ans = 0
p = list(map(int, input().split()))
for i in range(n - 1):
	e = list(map(int, input().split()))
	dif = (p[0] - e[0]) ** 2 + (p[1] - e[1]) ** 2
	p = e
	ans += dif ** 0.5 / 50
ans *= k
print(ans)


(n, k) = map(int, input().split())
l = [list(map(int, input().split())) for _ in range(n)]
t = 0
for i in range(1, n):
	t += ((l[i - 1][0] - l[i][0]) ** 2 + (l[i - 1][1] - l[i][1]) ** 2) ** 0.5
print(t * (k / 50))


(n, k) = map(int, input().split())
(x1, y1) = map(float, input().split())
sum = 0
for i in range(n - 1):
	(x2, y2) = map(float, input().split())
	d = pow(pow(x2 - x1, 2) + pow(y2 - y1, 2), 1 / 2)
	x1 = x2
	y1 = y2
	sum += d
ans = sum * k / 50
print(ans)


(n, k) = map(int, input().split())
pos = list(map(int, input().split()))
s = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	s += ((x - pos[0]) ** 2 + (y - pos[1]) ** 2) ** 0.5
	pos = [x, y]
print('%.7f' % (s / 50 * k))


cnt = lambda s, i: s.count(i)
iip = lambda : int(input())
sip = lambda : input()
f = lambda : map(int, input().split())
lf = lambda : list(map(int, input().split()))
(n, k) = f()
l = lf()
d = 0
for i in range(n - 1):
	l2 = lf()
	d += ((l2[0] - l[0]) ** 2 + (l2[1] - l[1]) ** 2) ** 0.5
	l = l2
print(d * k / 50)


import sys
my_file = sys.stdin
line = [int(i) for i in my_file.readline().strip().split()]
(n, k) = (line[0], line[1])
line = [list(map(int, i.strip().split())) for i in my_file.readlines()]
l = 0
for i in range(1, n):
	x = line[i][0] - line[i - 1][0]
	y = line[i][1] - line[i - 1][1]
	l += (x ** 2 + y ** 2) ** 0.5
print(l / 50 * k)


distancia = 0
(a, b) = map(int, input().split())
L = [tuple(map(int, input().split())) for k in range(a)]
for k in range(1, a):
	distancia += ((L[k][0] - L[k - 1][0]) ** 2 + (L[k][1] - L[k - 1][1]) ** 2) ** 0.5
distanciasegundos = distancia / 50 * b
print('%.9f' % distanciasegundos)


import math
(n, k) = map(int, input().split())
ans = 0
(prevx, prevy) = map(int, input().split())
for _ in range(n - 1):
	(x, y) = map(int, input().split())
	ans += math.sqrt(pow(x - prevx, 2) + pow(y - prevy, 2))
	(prevx, prevy) = (x, y)
print(k * ans / 50)


(n, k) = map(int, input().split())
c = 0
x = []
for i in range(n):
	(a, b) = map(int, input().split())
	x.append([a, b])
for i in range(1, n):
	(a, b) = (x[i][0] - x[i - 1][0], x[i][1] - x[i - 1][1])
	c += (a * a + b * b) ** 0.5
print(c / 50 * k)


(n, k) = map(int, input().split())
(a, b) = map(int, input().split())
r = 0
for i in range(n - 1):
	(x, y) = map(int, input().split())
	r += ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	(a, b) = (x, y)
print(round(r * k / 50, 6))


def main():
	from math import hypot
	[n, k] = [int(_) for _ in input().split()]
	pts = []
	for _ in range(n):
		[x, y] = [int(_) for _ in input().split()]
		pts += [(x, y)]
	ptdiff = lambda p: (p[0][0] - p[1][0], p[0][1] - p[1][1])
	diffs = map(ptdiff, zip(pts[:-1], pts[1:]))
	path = sum((hypot(d1, d2) for (d1, d2) in diffs))
	print(path / 50 * k)
main()


import math
import collections
cost = 0
(n, k) = input().split()
point = collections.namedtuple('point', 'x y')
list = []
for i in range(int(n)):
	(x, y) = input().split()
	list.append(point(int(x), int(y)))
for i in range(int(n) - 1):
	cost += math.hypot(list[i + 1][0] - list[i][0], list[i + 1][1] - list[i][1])
print(cost / 50 * int(k))


import math
things = [*map(int, input().split())]
distance = 0
prev_point = [*map(int, input().split())]
for _ in range(0, things[0] - 1):
	new_point = [*map(int, input().split())]
	distance += math.sqrt((new_point[0] - prev_point[0]) ** 2 + (new_point[1] - prev_point[1]) ** 2)
	prev_point = new_point
print(distance / 50.0 * things[1])


from collections import defaultdict
import math
(n, k) = map(int, input().split())
points = []

def dist(x, y):
	t1 = (y[0] - x[0]) ** 2
	t2 = (y[1] - x[1]) ** 2
	return math.sqrt(t1 + t2)
ans = 0
for _ in range(n):
	points.append(list(map(int, input().split())))
for i in range(n - 1):
	ans += dist(points[i], points[i + 1])
print(ans * k / 50)


import math
(n, k) = (int(x) for x in input().split())
coord = [list(map(int, input().split())) for _ in range(n)]
dist = [math.sqrt(pow(coord[i][0] - coord[i + 1][0], 2) + pow(coord[i][1] - coord[i + 1][1], 2)) for i in range(n - 1)]
print(sum(dist) * k / 50)


import math
(n, k) = map(int, input().split())
(x1, y1) = map(int, input().split())
time = 0
for _ in range(n - 1):
	(x2, y2) = map(int, input().split())
	dis = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	t = dis / 50
	time += t
	(x1, y1) = (x2, y2)
time *= k
print('%.9f' % time)


from math import sqrt

def d(x1, y1, x2, y2):
	return sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
(n, k) = [int(x) for x in input().split()]
a = []
for _ in range(n):
	a.append([int(x) for x in input().split()])
s = 0
for i in range(n - 1):
	s += d(a[i][0], a[i][1], a[i + 1][0], a[i + 1][1])
print(f'{s * k / 50:.9f}')


(n, k) = (int(x) for x in input().split())
(x1, y1) = (int(x) for x in input().split())
val = 0.0
for i in range(n - 1):
	(x2, y2) = (int(x) for x in input().split())
	val += ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
	(x1, y1) = (x2, y2)
print(val * k / 50)


from math import sqrt
a = input().split(' ')
p = []
ras = int(0)
for i in range(int(a[0])):
	p.append(input().split(' '))
for k in range(int(a[0]) - 1):
	ac = int(p[k][0]) - int(p[k + 1][0])
	bc = int(p[k][1]) - int(p[k + 1][1])
	ras += sqrt(ac ** 2 + bc ** 2)
print(ras * int(a[1]) / 50)


alph = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
E = 0
(x, y) = map(int, input().split())
for i in range(n - 1):
	(a, b) = map(int, input().split())
	r = ((x - a) ** 2 + (y - b) ** 2) ** 0.5
	E += r
	(x, y) = (a, b)
print('%.9f' % (E * k / 50))


import decimal
D = decimal.Decimal
l1 = [int(x) for x in input().split()]
(n, k) = (l1[0], l1[1])
prev = []
coords = []
distance = 0
for x in range(n):
	coords = [int(x) for x in input().split()]
	if x != 0:
		distance += D(((prev[0] - coords[0]) ** 2 + (prev[1] - coords[1]) ** 2) ** (1 / 2))
		prev[0] = int(coords[0])
		prev[1] = int(coords[1])
	else:
		prev.append(int(coords[0]))
		prev.append(int(coords[1]))
print(D(k * D(distance / 50)))


import math

def dist(x1, y1, x2, y2):
	return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
(n, k) = map(int, input().split())
(x, y) = (list(), list())
for i in range(n):
	(xx, yy) = map(int, input().split())
	x.append(xx)
	y.append(yy)
(i, ans) = (0, 0.0)
for j in range(1, n):
	ans += dist(x[i], y[i], x[j], y[j])
	i += 1
print('%.12f' % (ans * float(k) / 50.0))


from math import sqrt
(X, Last, SUM) = (list(map(int, input().split())), list(map(int, input().split())), 0)
for i in range(X[0] - 1):
	Temp = list(map(int, input().split()))
	SUM += sqrt((Last[0] - Temp[0]) ** 2 + (Last[1] - Temp[1]) ** 2)
	Last = Temp
print(SUM * X[1] / 50)


(n, k) = map(int, input().split())
(lx, ly) = map(int, input().split())
dist = 0
for _ in range(n - 1):
	(x, y) = map(int, input().split())
	dist += ((lx - x) ** 2 + (ly - y) ** 2) ** 0.5
	(lx, ly) = (x, y)
print(dist / 50 * k)


from math import hypot
(n, k) = map(int, input().split())
total_len = 0
(x, y) = map(int, input().split())
for _ in range(n - 1):
	(nx, ny) = map(int, input().split())
	total_len += hypot(x - nx, y - ny)
	(x, y) = (nx, ny)
print(k * total_len / 50)


(n, k) = map(int, input().split())
x0 = 0
y0 = 0
r = 0
for i in range(n):
	(x, y) = map(int, input().split())
	if i > 0:
		r += ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5
	x0 = x
	y0 = y
t = round(r * k / 50, 6)
print(t)


(n, k) = map(int, input().split())
z = [[int(i) for i in input().split()] for j in range(n)]
a = 0
for i in range(1, n):
	a += ((z[i - 1][0] - z[i][0]) ** 2 + (z[i - 1][1] - z[i][1]) ** 2) ** 0.5
print(a * k / 50)


import math

def main():
	(n, k) = map(int, input().split())
	(last_x, last_y) = map(float, input().split())
	distance = 0
	for _ in range(n - 1):
		(x, y) = map(float, input().split())
		distance += math.sqrt((x - last_x) ** 2 + (y - last_y) ** 2)
		(last_x, last_y) = (x, y)
	print(distance / 50 * k)
main()


def wasted_time(arr, k):
	sum = 0
	for i in range(len(arr) - 1):
		d = (arr[i][0] - arr[i + 1][0]) ** 2 + (arr[i][1] - arr[i + 1][1]) ** 2
		dist = d ** (1 / 2)
		sum = sum + dist
	fin = sum / 50 * k
	print(fin)
n = list(map(int, input('').split()))
b = []
for i in range(n[0]):
	a = list(map(int, input('').split()))
	b.append(a)
wasted_time(b, n[1])


(n, k) = [int(i) for i in input().split()]
t = 0
(x0, y0) = [float(i) for i in input().split()]
for i in range(1, n):
	(x, y) = [float(i) for i in input().split()]
	d = ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5
	(x0, y0) = (x, y)
	t += d / 50
print(t * k)


import math
(n, k) = map(int, input().split())
l = []
for i in range(n):
	(x, y) = map(int, input().split())
	l.append((x, y))
s = 0
for i in range(1, n):
	x1 = l[i - 1][0]
	y1 = l[i - 1][1]
	x2 = l[i][0]
	y2 = l[i][1]
	s += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) / 50
print(s * k)


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

def I():
	return int(input())

def S():
	return str(input())

def L():
	return list(R())
from collections import Counter
import math
import sys
(n, k) = R()
x = [0] * n
y = [0] * n
for i in range(n):
	(x[i], y[i]) = R()
l = 0
for i in range(n - 1):
	l += math.sqrt((x[i] - x[i + 1]) ** 2 + (y[i] - y[i + 1]) ** 2)
print(l * k / 50)