Petya is having a party soon, and he has decided to invite his $n$ friends.

He wants to make invitations in the form of origami. For each invitation, he needs two red sheets, five green sheets, and eight blue sheets. The store sells an infinite number of notebooks of each color, but each notebook consists of only one color with $k$ sheets. That is, each notebook contains $k$ sheets of either red, green, or blue.

Find the minimum number of notebooks that Petya needs to buy to invite all $n$ of his friends.


-----Input-----

The first line contains two integers $n$ and $k$ ($1\leq n, k\leq 10^8$) — the number of Petya's friends and the number of sheets in each notebook respectively.


-----Output-----

Print one number — the minimum number of notebooks that Petya needs to buy.


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

Output
10

Input
15 6

Output
38



-----Note-----

In the first example, we need $2$ red notebooks, $3$ green notebooks, and $5$ blue notebooks.

In the second example, we need $5$ red notebooks, $13$ green notebooks, and $20$ blue notebooks.

Difficulty: EASY
Tags: Mathematics
Expected Time Complexity: O(1)

Starter code:

Solutions:
from sys import stdin
from math import ceil
(n, k) = map(int, stdin.readline().strip().split())
a = 2 * n
b = 5 * n
c = 8 * n
print(ceil(a / k) + ceil(b / k) + ceil(c / k))


from math import ceil
nAndK = input().strip().split()
numberOfFriends = int(nAndK[0])
sheetsOfPaperNotebook = int(nAndK[1])
numRedBooks = ceil(numberOfFriends * 2 / sheetsOfPaperNotebook)
numGreenBooks = ceil(numberOfFriends * 5 / sheetsOfPaperNotebook)
numBlueBooks = ceil(numberOfFriends * 8 / sheetsOfPaperNotebook)
print(numRedBooks + numGreenBooks + numBlueBooks)


a = input().split()
n = int(a[0])
k = int(a[1])
s = 0
if 2 * n / k > 2 * n // k:
	i = 2 * n // k + 1
else:
	i = 2 * n // k
s = s + i
if 5 * n / k > 5 * n // k:
	i = 5 * n // k + 1
else:
	i = 5 * n // k
s = s + i
if 8 * n / k > 8 * n // k:
	i = 8 * n // k + 1
else:
	i = 8 * n // k
s = s + i
print(s)


s = list(map(int, input().split(' ')))
n = s[0]
k = s[1]
cnt = 0
r = n * 2
if r % k == 0:
	cnt = cnt + r // k
elif r % k > 0:
	cnt = cnt + r // k + 1
g = n * 5
if g % k == 0:
	cnt = cnt + g // k
elif g % k > 0:
	cnt = cnt + g // k + 1
b = n * 8
if b % k == 0:
	cnt = cnt + b // k
elif b % k > 0:
	cnt = cnt + b // k + 1
print(cnt)


import math

class CodeforcesTask1080ASolution:

	def __init__(self):
		self.result = ''
		self.n_k = []

	def read_input(self):
		self.n_k = [int(x) for x in input().split(' ')]

	def process_task(self):
		mats = [x * self.n_k[0] for x in [2, 5, 8]]
		nbs = [x // self.n_k[1] + math.ceil(x % self.n_k[1] / self.n_k[1]) for x in mats]
		self.result = str(sum(nbs))

	def get_result(self):
		return self.result
Solution = CodeforcesTask1080ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


from math import ceil
(n, k) = map(int, input().split())
print(ceil(2 * n / k) + ceil(5 * n / k) + ceil(8 * n / k))


(n, m) = list(map(int, input().split()))
k = n * 2
z = n * 5
s = n * 8
ans = 0
if k % m != 0:
	ans += int(k / m) + 1
else:
	ans += int(k / m)
if z % m != 0:
	ans += int(z / m) + 1
else:
	ans += int(z / m)
if s % m != 0:
	ans += int(s / m) + 1
else:
	ans += int(s / m)
print(ans)


(n, k) = map(int, input().split())
x = 2 * n // k
if 2 * n % k != 0:
	x += 1
y = 5 * n // k
if 5 * n % k != 0:
	y += 1
z = 8 * n // k
if 8 * n % k != 0:
	z += 1
print(x + y + z)


def main():
	(n, k) = map(int, input().split())
	count_1 = n * 2 // k + 1 if n * 2 % k != 0 else n * 2 // k
	count_2 = n * 5 // k + 1 if n * 5 % k != 0 else n * 5 // k
	count_3 = n * 8 // k + 1 if n * 8 % k != 0 else n * 8 // k
	answer = count_1 + count_2 + count_3
	print(answer)
main()


import math

def solve(n, k):
	return math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)
from sys import stdin

def intRead():
	while True:
		ln = stdin.readline().strip()
		if not ln:
			return
		for i in map(int, ln.split()):
			yield i
ipt = intRead()
n = next(ipt)
k = next(ipt)
print(solve(n, k))


(n, k) = map(int, input().split())
kr = 2 * n
z = 5 * n
s = 8 * n
print(kr // k + bool(kr % k) + z // k + bool(z % k) + s // k + bool(s % k))


import math
a = [int(i) for i in input().split(' ')]
n = a[0]
k = a[1]
red = n * 2
green = n * 5
blue = n * 8
print(math.ceil(blue / k) + math.ceil(red / k) + math.ceil(green / k))


import math
(n, k) = map(int, input().split())
red_paper = n * 2
green_paper = n * 5
blue_paper = n * 8
res = math.ceil(red_paper / k) + math.ceil(green_paper / k) + math.ceil(blue_paper / k)
print(res)


import sys
import math
input = sys.stdin.readline
(n, k) = map(int, input().split())
print(math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k))


n = input()
n = n.split(' ')
k = int(n[1])
n = int(n[0])
r = 2
g = 5
b = 8
while n < 1 or k < 1 or n > 1000000000.0 or (k > 1000000000.0):
	n = input()
	n = n.split(' ')
	k = n[1]
	n = n[0]
rn = r * n
gn = g * n
bn = b * n
rk = rn // k
if rn % k != 0:
	rk += 1
gk = gn // k
if gn % k != 0:
	gk += 1
bk = bn // k
if bn % k != 0:
	bk += 1
summ = rk + gk + bk
print(summ)


(n, k) = map(int, input().split())
u = n * 2
v = n * 5
t = n * 8
if t % k == 0 and v % k == 0 and (u % k == 0):
	ans = t // k + v // k + u // k
elif t % k != 0 and v % k == 0 and (u % k == 0):
	ans = t // k + v // k + u // k + 1
elif t % k == 0 and v % k != 0 and (u % k == 0):
	ans = t // k + v // k + u // k + 1
elif t % k == 0 and v % k == 0 and (u % k != 0):
	ans = t // k + v // k + u // k + 1
elif t % k != 0 and v % k != 0 and (u % k == 0):
	ans = t // k + v // k + u // k + 2
elif t % k != 0 and v % k == 0 and (u % k != 0):
	ans = t // k + v // k + u // k + 2
elif t % k == 0 and v % k != 0 and (u % k != 0):
	ans = t // k + v // k + u // k + 2
else:
	ans = t // k + v // k + u // k + 3
print(ans)


a = input()
a = a.split(' ')
n = int(a[0])
k = int(a[1])
red = 2 * n // k
if 2 * n % k != 0:
	red += 1
green = 5 * n // k
if 5 * n % k != 0:
	green += 1
blue = 8 * n // k
if 8 * n % k != 0:
	blue += 1
print(red + green + blue)


import math
try:
	(n, k) = map(int, input().split())
	red_notebook = math.ceil(n * 2 / k)
	green_notebook = math.ceil(n * 5 / k)
	blue_notebook = math.ceil(n * 8 / k)
	print(red_notebook + blue_notebook + green_notebook)
except:
	pass


(m, n) = map(int, input().split())
import math
print(math.ceil(2 * m / n) + math.ceil(5 * m / n) + math.ceil(8 * m / n))


import math
(n, k) = list(map(int, input().split()))
reqr = n * 2
reqg = n * 5
reqb = n * 8
print(math.ceil(reqr / k) + math.ceil(reqb / k) + math.ceil(reqg / k))


l = [int(x) for x in input().split()]
n = l[0]
k = l[1]
a = n * 2
b = n * 5
c = n * 8
count = 0
if a / k > a // k:
	count += a // k + 1
else:
	count += a // k
if b / k > b // k:
	count += b // k + 1
else:
	count += b // k
if c / k > c // k:
	count += c // k + 1
else:
	count += c // k
print(count)


(n, k) = map(int, input().split())
tr = int(2 * n / k)
tg = int(5 * n / k)
tb = int(8 * n / k)
if 2 * n % k != 0:
	tr = tr + 1
if 5 * n % k != 0:
	tg = tg + 1
if 8 * n % k != 0:
	tb = tb + 1
s = tr + tg + tb
print(s)


(n, k) = map(int, input().split())
ans = 0
for i in [2, 5, 8]:
	ans += (n * i + k - 1) // k
print(ans)


from math import ceil
(n, k) = list(map(int, input().strip().split()))
r = 2 * n
g = 5 * n
b = 8 * n
print(ceil(r / k) + ceil(g / k) + ceil(b / k))


leitura = input().split(' ')
n = int(leitura[0])
k = int(leitura[1])
vermelho = int(2 * n / k)
if 2 * n % k != 0:
	vermelho += 1
verde = int(5 * n / k)
if 5 * n % k != 0:
	verde += 1
azul = int(8 * n / k)
if 8 * n % k != 0:
	azul += 1
resposta_final_super = vermelho + verde + azul
print(resposta_final_super)


input = input().split(' ')
n = int(input[0])
k = int(input[1])

def number_books(n, k):
	return (2 * n + k - 1) // k + (5 * n + k - 1) // k + (8 * n + k - 1) // k
print(number_books(n, k))


(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
result = r // k + b // k + g // k
if r % k != 0:
	result += 1
if g % k != 0:
	result += 1
if b % k != 0:
	result += 1
print(result)


import math
(guests, lists) = map(int, input().split())
red = math.ceil(2 * guests / lists)
green = math.ceil(5 * guests / lists)
blue = math.ceil(8 * guests / lists)
print(red + green + blue)


import sys, math
(a, b) = map(int, sys.stdin.readline().split())
total = 0
total += math.ceil(a * 2 / b)
total += math.ceil(a * 5 / b)
total += math.ceil(a * 8 / b)
print(total)


x = [int(x) for x in input().split()]
total_notebooks = 0
total_notebooks += 2 * x[0] // x[1] + (1 if 2 * x[0] % x[1] > 0 else 0)
total_notebooks += 5 * x[0] // x[1] + (1 if 5 * x[0] % x[1] > 0 else 0)
total_notebooks += 8 * x[0] // x[1] + (1 if 8 * x[0] % x[1] > 0 else 0)
print(total_notebooks)


import math
(n, k) = map(int, input().split())
(red, green, blue) = (2 * n, 5 * n, 8 * n)
print(math.ceil(red / k) + math.ceil(green / k) + math.ceil(blue / k))


(n, k) = map(int, input().split())
red = n * 2 // k + (0 if n * 2 % k == 0 else 1)
green = n * 5 // k + (0 if n * 5 % k == 0 else 1)
blue = n * 8 // k + (0 if n * 8 % k == 0 else 1)
print(red + green + blue)


import math
(friends, n_sheets) = [int(x) for x in input().split()]
red = math.ceil(2 * friends / n_sheets)
green = math.ceil(5 * friends / n_sheets)
blue = math.ceil(8 * friends / n_sheets)
n_notebooks = red + green + blue
print(n_notebooks)


import math
(n, k) = map(int, input().split())
cnt = 0
cnt += math.ceil(n * 2 / k)
cnt += math.ceil(n * 5 / k)
cnt += math.ceil(n * 8 / k)
print(cnt)


(n, k) = map(int, input().split())
print(sum(((n * c + k - 1) // k for c in (2, 5, 8))))


x = list(map(int, input().split()))
a = x[0]
b = x[1]
if a * 2 % b == 0:
	q = a * 2 // b
else:
	q = a * 2 // b + 1
if a * 5 % b == 0:
	w = a * 5 // b
else:
	w = a * 5 // b + 1
if a * 8 % b == 0:
	e = a * 8 // b
else:
	e = a * 8 // b + 1
print(q + w + e)


(n, k) = [int(x) for x in input().split(' ')]
red_sheets = 2 * n
green_sheets = 5 * n
blue_sheets = 8 * n

def findrequiredsheets(reqd):
	if reqd % k == 0:
		return int(reqd / k)
	else:
		return int(reqd / k) + 1
output = findrequiredsheets(2 * n) + findrequiredsheets(5 * n) + findrequiredsheets(8 * n)
print(output)


sheet = [2, 5, 8]
(n, k) = map(int, input().split())
sheet[0] *= n
sheet[1] *= n
sheet[2] *= n
sum = 0
if sheet[0] % k == 0:
	sum += sheet[0] // k
else:
	sum += sheet[0] // k + 1
if sheet[1] % k == 0:
	sum += sheet[1] // k
else:
	sum += sheet[1] // k + 1
if sheet[2] % k == 0:
	sum += sheet[2] // k
else:
	sum += sheet[2] // k + 1
print(sum)


import math
(n, k) = (int(i) for i in input().split())
print(math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k))


import math as m
(n, k) = map(int, input().split())
a = 2 * n
b = 5 * n
c = 8 * n
print(m.ceil(a / k) + m.ceil(c / k) + m.ceil(b / k))


def petyaAndOrigami(n, k):
	red = 2 * n // k
	green = 5 * n // k
	blue = 8 * n // k
	r = 2 * n % k
	g = 5 * n % k
	b = 8 * n % k
	if r != 0:
		red = red + 1
	if g != 0:
		green = green + 1
	if b != 0:
		blue = blue + 1
	sum = red + green + blue
	return sum

def main():
	(n, k) = map(int, input().split())
	print(petyaAndOrigami(n, k))
main()


def cnt(n, k):
	return 1 + (n - 1) // k
(n, k) = map(int, input().split())
print(cnt(2 * n, k) + cnt(5 * n, k) + cnt(8 * n, k))


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
if r % k == 0:
	x = r // k
else:
	x = r // k + 1
if g % k == 0:
	y = g // k
else:
	y = g // k + 1
if b % k == 0:
	z = b // k
else:
	z = b // k + 1
print(x + y + z)


a = input().split()
m = int(a[0])
s = int(a[1])
l = [m * 2, m * 5, m * 8]
b = 0
for i in l:
	if i % s == 0:
		b += i // s
	else:
		b += i // s + 1
print(b)


u = list(map(int, input().strip().split()))
r = 2
g = 5
b = 8
n = u[0]
k = u[1]
r = r * n
g = g * n
b = b * n
req1 = r // k
if r % k != 0:
	req1 = req1 + 1
req2 = g // k
if g % k != 0:
	req2 = req2 + 1
req3 = b // k
if b % k != 0:
	req3 = req3 + 1
print(req1 + req2 + req3)


def origami(n, k):
	red = 2 * n
	green = 5 * n
	blue = 8 * n
	books = red // k + 1 if red % k != 0 else red // k
	books += green // k + 1 if green % k != 0 else green // k
	books += blue // k + 1 if blue % k != 0 else blue // k
	return books
(n, k) = list(map(int, input().rstrip().split()))
print(origami(n, k))


from math import *
(n, k) = [int(x) for x in input().split()]
print(ceil(n * 2 / k) + ceil(n * 5 / k) + ceil(n * 8 / k))


(n, k) = map(int, input().split())
a = 2 * n
b = 5 * n
c = 8 * n
print((a + k - 1) // k + (b + k - 1) // k + (c + k - 1) // k)


(n, k) = map(int, input().split())
red = n * 2
green = n * 5
blue = n * 8
print(red // k + (red % k != 0) + green // k + (green % k != 0) + blue // k + (blue % k != 0))


import math

def notebook_count(n, k):
	return math.ceil(8 * n / k) + math.ceil(5 * n / k) + math.ceil(2 * n / k)
(n, k) = map(int, input().split())
print(notebook_count(n, k))


(n, k) = map(int, input().split())
red = n * 2
green = n * 5
blue = n * 8
ans = (red + k - 1) // k + (green + k - 1) // k + (blue + k - 1) // k
print(ans)


import math

def main():
	(n, k) = input().split()
	n = int(n)
	k = int(k)
	red_sheets = n * 2
	green_sheets = n * 5
	blue_sheets = n * 8
	notebooks = 0
	if red_sheets // k < 1:
		notebooks += 1
	else:
		notebooks += red_sheets // k
		if red_sheets % k > 0:
			notebooks += 1
	if green_sheets // k < 1:
		notebooks += 1
	else:
		notebooks += green_sheets // k
		if green_sheets % k > 0:
			notebooks += 1
	if blue_sheets // k < 1:
		notebooks += 1
	else:
		notebooks += blue_sheets // k
		if blue_sheets % k > 0:
			notebooks += 1
	print(notebooks)
main()


def mainA():
	(n, k) = map(int, input().split())
	a = (2 * n, 5 * n, 8 * n)
	print(sum(map(lambda x: (x + k - 1) // k, a)))
mainA()


(n, k) = input().split()
n = int(n)
k = int(k)
r = [0, 0, 0]
r[0] = 2 * n
r[1] = 5 * n
r[2] = 8 * n
count = 0
for i in range(3):
	count += r[i] // k
	if r[i] % k != 0:
		count += 1
print(count)


list1 = [int(x) for x in input().split()]
friend = list1[0]
page = list1[1]
col = 2
tot = 0
while col < 9:
	if friend * col % page == 0:
		tot = tot + friend * col // page
		col = col + 3
	else:
		tot = tot + friend * col // page + 1
		col = col + 3
print(tot)


(n, k) = map(int, input().split())
books = 0
if n * 2 % k != 0:
	books += n * 2 // k + 1
else:
	books += n * 2 // k
if n * 5 % k != 0:
	books += n * 5 // k + 1
else:
	books += n * 5 / k
if n * 8 % k != 0:
	books += n * 8 // k + 1
else:
	books += n * 8 // k
print(int(books))


import math
(a, b) = input().split()
blue = int(a) * 8
green = int(a) * 5
red = int(a) * 2
need = math.ceil(blue / int(b)) + math.ceil(green / int(b)) + math.ceil(red / int(b))
print(need)


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys
sys.setrecursionlimit(10000000)

class Operation:

	def __init__(self, name, function, function_on_equal, neutral_value=0):
		self.name = name
		self.f = function
		self.f_on_equal = function_on_equal

def add_multiple(x, count):
	return x * count

def min_multiple(x, count):
	return x

def max_multiple(x, count):
	return x
sum_operation = Operation('sum', sum, add_multiple, 0)
min_operation = Operation('min', min, min_multiple, 1000000000.0)
max_operation = Operation('max', max, max_multiple, -1000000000.0)

class SegmentTree:

	def __init__(self, array, operations=[sum_operation, min_operation, max_operation]):
		self.array = array
		if type(operations) != list:
			raise TypeError('operations must be a list')
		self.operations = {}
		for op in operations:
			self.operations[op.name] = op
		self.root = SegmentTreeNode(0, len(array) - 1, self)

	def query(self, start, end, operation_name):
		if self.operations.get(operation_name) == None:
			raise Exception('This operation is not available')
		return self.root._query(start, end, self.operations[operation_name])

	def summary(self):
		return self.root.values

	def update(self, position, value):
		self.root._update(position, value)

	def update_range(self, start, end, value):
		self.root._update_range(start, end, value)

	def __repr__(self):
		return self.root.__repr__()

class SegmentTreeNode:

	def __init__(self, start, end, segment_tree):
		self.range = (start, end)
		self.parent_tree = segment_tree
		self.range_value = None
		self.values = {}
		self.left = None
		self.right = None
		if start == end:
			self._sync()
			return
		self.left = SegmentTreeNode(start, start + (end - start) // 2, segment_tree)
		self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end, segment_tree)
		self._sync()

	def _query(self, start, end, operation):
		if end < self.range[0] or start > self.range[1]:
			return None
		if start <= self.range[0] and self.range[1] <= end:
			return self.values[operation.name]
		self._push()
		left_res = self.left._query(start, end, operation) if self.left else None
		right_res = self.right._query(start, end, operation) if self.right else None
		if left_res is None:
			return right_res
		if right_res is None:
			return left_res
		return operation.f([left_res, right_res])

	def _update(self, position, value):
		if position < self.range[0] or position > self.range[1]:
			return
		if position == self.range[0] and self.range[1] == position:
			self.parent_tree.array[position] = value
			self._sync()
			return
		self._push()
		self.left._update(position, value)
		self.right._update(position, value)
		self._sync()

	def _update_range(self, start, end, value):
		if end < self.range[0] or start > self.range[1]:
			return
		if start <= self.range[0] and self.range[1] <= end:
			self.range_value = value
			self._sync()
			return
		self._push()
		self.left._update_range(start, end, value)
		self.right._update_range(start, end, value)
		self._sync()

	def _sync(self):
		if self.range[0] == self.range[1]:
			for op in self.parent_tree.operations.values():
				current_value = self.parent_tree.array[self.range[0]]
				if self.range_value is not None:
					current_value = self.range_value
				self.values[op.name] = op.f([current_value])
		else:
			for op in self.parent_tree.operations.values():
				result = op.f([self.left.values[op.name], self.right.values[op.name]])
				if self.range_value is not None:
					bound_length = self.range[1] - self.range[0] + 1
					result = op.f_on_equal(self.range_value, bound_length)
				self.values[op.name] = result

	def _push(self):
		if self.range_value is None:
			return
		if self.left:
			self.left.range_value = self.range_value
			self.right.range_value = self.range_value
			self.left._sync()
			self.right._sync()
			self.range_value = None

	def __repr__(self):
		ans = '({}, {}): {}\n'.format(self.range[0], self.range[1], self.values)
		if self.left:
			ans += self.left.__repr__()
		if self.right:
			ans += self.right.__repr__()
		return ans

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

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

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

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False
testingMode = False
optimiseForReccursion = False

def main():
	(n, k) = get_tuple()
	print(math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k))
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


(x, y) = [int(i) for i in input().split()]
a = 2 * x
d = 5 * x
c = 8 * x
r = a // y
g = d // y
b = c // y
if a % y != 0:
	r = r + 1
if d % y != 0:
	g = g + 1
if c % y != 0:
	b = b + 1
n = r + g + b
print(n)


import math
(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
x = math.ceil(r / k)
y = math.ceil(g / k)
z = math.ceil(b / k)
print(x + y + z)


import sys
from collections import *

def solve(io):
	N = io.read_int()
	K = io.read_int()
	io.println((N * 2 + K - 1) // K + (N * 5 + K - 1) // K + (N * 8 + K - 1) // K)

class IO:
	in_stream = None
	out_stream = None
	raw = ''
	buf = []
	pos = 0

	def __init__(self, input_stream, output_stream):
		self.in_stream = input_stream
		self.out_stream = output_stream

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

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

	def read_int(self):
		return int(self.read_string())

	def read_float(self):
		return float(self.read_string())

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

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

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

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

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

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

	def println_array(self, arr, sep=' '):
		self.println(sep.join((str(x) for x in arr)))

	def flush_output(self):
		self.out_stream.flush()
pythonIO = IO(sys.stdin, sys.stdout)
solve(pythonIO)
pythonIO.flush_output()


import math
(friend, sheet) = map(int, input().split())
(2, 5, 8)
red = 2 * friend
blue = 5 * friend
green = 8 * friend
total = [red, blue, green]
summ = 0
for i in total:
	summ += math.ceil(i / sheet)
print(summ)


(a, b) = map(int, input().split())
c = a * 2 // b
d = a * 5 // b
e = a * 8 // b
if a * 2 != c * b:
	c += 1
if a * 8 != e * b:
	e += 1
if a * 5 != d * b:
	d += 1
print(c + d + e)


(n, k) = map(int, input().split())
print(n * 2 // k + bool(n * 2 % k) + n * 5 // k + bool(n * 5 % k) + n * 8 // k + bool(n * 8 % k))


(n, k) = map(int, input().split())
r = 2 * n // k
g = 5 * n // k
h = 8 * n // k
if 2 * n % k == 0:
	a = r
else:
	a = r + 1
if 5 * n % k == 0:
	b = g
else:
	b = g + 1
if 8 * n % k == 0:
	c = h
else:
	c = h + 1
print(a + b + c)


p = input()
a = p.index(' ')
k = a
a = int(p[:a])
p = p[k + 1:]
k = int(p)
r = a * 2
g = a * 5
b = 8 * a
ans = 0
if r % k == 0:
	ans += r / k
else:
	ans += r // k + 1
if g % k == 0:
	ans += g / k
else:
	ans += g // k + 1
if b % k == 0:
	ans += b / k
else:
	ans += b // k + 1
ans = int(ans)
print(ans)


(n1, k1) = input().split()
n = int(n1)
k = int(k1)
c = 0
r = 2 * n
g = 5 * n
b = 8 * n
if r % k != 0:
	c += 1
if g % k != 0:
	c += 1
if b % k != 0:
	c += 1
s = r // k + g // k + b // k
print(s + c)


import math
needs_per_friend = [2, 5, 8]
(n, k) = [int(x) for x in input().split()]
needs = [x * n for x in needs_per_friend]
print(sum((math.ceil(need / k) for need in needs)))


import math
(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
a = math.ceil(r / k)
a = a + math.ceil(g / k)
a = a + math.ceil(b / k)
print(a)


from sys import stdin

def main():
	(N, K) = map(int, input().split())
	(red, green, blue) = (2, 5, 8)
	sheets = 0
	for i in (2, 5, 8):
		sheets += (i * N + K - 1) // K
	print(sheets)
input = lambda : stdin.readline()
main()


(n, k) = map(int, input().split())
ans = sum(map(lambda x: (x * n + (k - 1)) // k, [2, 5, 8]))
print(ans)


import math

def solve(n, k):
	return math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)

def main():
	(n, k) = list(map(int, input().split()))
	print(solve(n, k))
main()


(n, k) = map(int, input().split())
print((2 * n - 1) // k + 1 + (5 * n - 1) // k + 1 + (8 * n - 1) // k + 1)


def ceil(a, b):
	return -(-a // b)
(n, k) = map(int, input().split())
print(ceil(n * 2, k) + ceil(n * 5, k) + ceil(n * 8, k))


y = list(map(int, input().split()))
r = y[0] * 2 % y[1]
g = y[0] * 5 % y[1]
b = y[0] * 8 % y[1]
win = 0
if r == 0:
	win = win + y[0] * 2 // y[1]
else:
	win = win + y[0] * 2 // y[1] + 1
if g == 0:
	win = win + y[0] * 5 // y[1]
else:
	win = win + y[0] * 5 // y[1] + 1
if b == 0:
	win = win + y[0] * 8 // y[1]
else:
	win = win + y[0] * 8 // y[1] + 1
print(win)


(x, y) = [int(t) for t in input().split()]
total = 0
red_needed = 2 * x
blue_needed = 5 * x
green_needed = 8 * x
if red_needed % y == 0:
	total += red_needed / y
else:
	total += red_needed // y + 1
if blue_needed % y == 0:
	total += blue_needed / y
else:
	total += blue_needed // y + 1
if green_needed % y == 0:
	total += green_needed / y
else:
	total += green_needed // y + 1
print(int(total))


import math
red = 2
green = 5
blue = 8
(friends, sheets) = [int(i) for i in input().split()]
print(math.ceil(friends * red / sheets) + math.ceil(friends * green / sheets) + math.ceil(friends * blue / sheets))


(n, k) = map(int, input().split())
a = (n * 2 - 1) // k + (n * 5 - 1) // k + (n * 8 - 1) // k + 3
print(a)


(n, k) = map(int, input().split())
red = n * 2
green = n * 5
blue = n * 8
if red % k == 0:
	x = int(red / k)
else:
	x = int(red / k) + 1
if green % k == 0:
	y = int(green / k)
else:
	y = int(green / k) + 1
if blue % k == 0:
	z = int(blue / k)
else:
	z = int(blue / k) + 1
total_books = x + y + z
print(total_books)


import math
(n, p) = map(int, input().split())
(r, g, b) = (n * 2, n * 5, n * 8)
if r / p > r // p:
	r1 = math.ceil(r / p)
elif r / p == r // p:
	r1 = r / p
if g / p > g // p:
	g1 = math.ceil(g / p)
elif g / p == g // p:
	g1 = g / p
if b / p > b // p:
	b1 = math.ceil(b / p)
elif b / p == b // p:
	b1 = b / p
print(int(r1 + g1 + b1))


(a, b) = map(int, input().split())
q = 2 * a
w = 5 * a
e = 8 * a
u = [q, w, e]
z = []
for i in u:
	if i % b == 0:
		t = i / b
		z.append(t)
	else:
		p = i // b + 1
		z.append(p)
print(int(sum(z)))


import sys, math

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

def main():
	(n, k) = mp()
	a = [2, 5, 8]
	s = 0
	for i in a:
		s += (n * i - 1) // k + 1
	print(s)
debug = 0
if debug:
	file = open('input.txt', 'r')
	input = file.readline
main()
if debug:
	file.close()


(n, k) = [int(i) for i in input().split()]
print((n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k)


line = input().split()
friends = int(line[0])
sheets = int(line[1])
red = 2
green = 5
blue = 8

def is_integer(n):
	return n % 1 == 0
red_notebook = red * friends / sheets
if not is_integer(red_notebook):
	red_notebook = int(red_notebook) + 1
green_notebook = green * friends / sheets
if not is_integer(green_notebook):
	green_notebook = int(green_notebook) + 1
blue_notebook = blue * friends / sheets
if not is_integer(blue_notebook):
	blue_notebook = int(blue_notebook) + 1
print(int(red_notebook + green_notebook + blue_notebook))


import math
a = list(map(int, input().split()))
x = math.ceil(a[0] * 8 / a[1]) + math.ceil(a[0] * 5 / a[1]) + math.ceil(a[0] * 2 / a[1])
print(x)


import sys
import math
inp_value = input().split()
n = int(inp_value[0])
k = int(inp_value[1])
red = 2 * n
green = 5 * n
blue = 8 * n
total_red = math.ceil(red / k)
total_green = math.ceil(green / k)
total_blue = math.ceil(blue / k)
print(total_red + total_green + total_blue)


print((lambda n, k: sum(((n * color + k - 1) // k for color in [2, 5, 8])))(*[int(x) for x in input().split()]))


z = input
(a, b) = map(int, z().split())
r = a * 2
g = a * 5
bl = a * 8
import math
t1 = math.ceil(r / b)
t2 = math.ceil(g / b)
t3 = math.ceil(bl / b)
print(t1 + t2 + t3)


import sys
n_k = sys.stdin.readline().strip().split()
(n, k) = (int(n_k[0]), int(n_k[1]))
n_red = 2 * n
n_green = 5 * n
n_blue = 8 * n
n_notebooks = 0
n_notebooks += (n_red + k - 1) // k
n_notebooks += (n_green + k - 1) // k
n_notebooks += (n_blue + k - 1) // k
print(n_notebooks)


(n, k) = map(float, input().split())
p = k / 2
zz = list()
q = k / 5
r = k / 8
co = 0
l = [p, q, r]
for i in l:
	z = n / i
	if z > int(z):
		zz.append(int(z) + 1)
	else:
		zz.append(int(z))
su = 0
for j in zz:
	su += j
print(int(su))


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from math import sqrt, floor, factorial, gcd, log
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
from math import gcd
from bisect import bisect
input = lambda : sys.stdin.readline().rstrip('\r\n')
read = lambda : list(map(int, input().strip().split(' ')))

def solve():
	(n, k) = read()
	a = 2 * n // k + [0, 1][2 * n % k > 0]
	b = 5 * n // k + [0, 1][5 * n % k > 0]
	c = 8 * n // k + [0, 1][8 * n % k > 0]
	print(a + b + c)
solve()


def petya():
	(n, s) = map(int, input().split())
	r = n * 2
	g = n * 5
	b = n * 8
	su = 0
	su += r // s + g // s + b // s
	if r % s > 0:
		su += 1
	if g % s > 0:
		su += 1
	if b % s > 0:
		su += 1
	print(su)
petya()


def main():
	list = input()
	list = list.split()
	n = int(list[0])
	k = int(list[1])
	redP = 2 * n
	greenP = 5 * n
	blueP = 8 * n
	(red, green, blue) = (0, 0, 0)
	if redP % k == 0:
		red = redP / k
	else:
		while redP > 0:
			redP -= k
			red += 1
	if greenP % k == 0:
		green = greenP / k
	else:
		while greenP > 0:
			greenP -= k
			green += 1
	if blueP % k == 0:
		blue = blueP / k
	else:
		while blueP > 0:
			blueP -= k
			blue += 1
	print(int(red + green + blue))
main()


(n, k) = map(int, input().split())
sheets = []
sheets.append(2 * n)
sheets.append(5 * n)
sheets.append(8 * n)
p = 0
for i in sheets:
	p += (i - 1) // k + 1
print(p)


import math
(n, k) = map(int, input().split())
count = 0
list = []
list.append(n * 2)
list.append(n * 5)
list.append(n * 8)
for i in range(0, 3):
	j = math.ceil(list[i] / k)
	count = count + j
print(count)


import math as m
(a, b) = map(int, input().split())
print(m.ceil(2 * a / b) + m.ceil(5 * a / b) + m.ceil(8 * a / b))


import math
(n, k) = (int(x) for x in input().split())
c = 2 * n
z = 5 * n
s = 8 * n
print(math.ceil(c / k) + math.ceil(z / k) + math.ceil(s / k))


from math import *
import sys, random

def nextInt():
	return int(input())

def nextStrs():
	return input().split()

def nextInts():
	return list(map(int, nextStrs()))

def main():
	(n, k) = nextInts()
	red = n * 2
	green = n * 5
	blue = n * 8
	print(ceil(red / k) + ceil(green / k) + ceil(blue / k))
exit(main())


a = [int(i) for i in input().split()]
print((2 * a[0] - 1) // a[1] + (5 * a[0] - 1) // a[1] + (8 * a[0] - 1) // a[1] + 3)


s = input().split()
(n, m) = (int(s[0]), int(s[1]))
(a, b, c) = (n * 8, n * 5, n * 2)
print((a - 1) // m + 1 + ((b - 1) // m + 1) + ((c - 1) // m + 1))


def ans(n, k):
	(r, g, b) = (n * 2, n * 5, n * 8)
	cnt = 0
	if r % k:
		cnt += r // k + 1
	else:
		cnt += r // k
	if g % k:
		cnt += g // k + 1
	else:
		cnt += g // k
	if b % k:
		cnt += b // k + 1
	else:
		cnt += b // k
	return cnt
nk = list(map(int, input().strip().split()))
(n, k) = (nk[0], nk[1])
print(ans(n, k))


import math as m
en = list(map(int, input().split()))
n = en[0]
k = en[1]
mir = n * 2
mig = n * 5
mib = n * 8
tot = 0
tot += m.ceil(mir / k)
tot += m.ceil(mig / k)
tot += m.ceil(mib / k)
print(tot)


import math
inp1 = list(map(int, input().strip().split()))[:2]
(n, k) = (inp1[0], inp1[1])
(r, g, b) = (n * 2, n * 5, n * 8)
print(math.ceil(r / k) + math.ceil(g / k) + math.ceil(b / k))


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import ceil as c
(n, k) = I()
print(c(n * 2 / k) + c(n * 5 / k) + c(n * 8 / k))


(n, k) = map(int, input().split())
ans = 0
ans += (n * 2 + k - 1) // k
ans += (n * 5 + k - 1) // k
ans += (n * 8 + k - 1) // k
print(ans)


(n, k) = input().split()
n = int(n)
k = int(k)
red = 2 * n
green = 5 * n
blue = 8 * n
soma = 0
if (red / k).is_integer():
	soma += red / k
else:
	soma += red // k + 1
if (green / k).is_integer():
	soma += green / k
else:
	soma += green // k + 1
if (blue / k).is_integer():
	soma += blue / k
else:
	soma += blue // k + 1
print(int(soma))


import math
(n, k) = (int(t) for t in input().split())
r = 2 * n
g = 5 * n
b = 8 * n
print(math.ceil(r / k) + math.ceil(g / k) + math.ceil(b / k))


(n, k) = map(int, input().strip().split(' '))
s = 0
s = n * 8 // k
c = n * 8 % k
if c > 0:
	s += 1
s += n * 5 // k
c = n * 5 % k
if c > 0:
	s += 1
s += n * 2 // k
c = n * 2 % k
if c > 0:
	s += 1
print(s)


import math
b = list(map(int, input().split()))
n = b[0]
k = b[1]
print(math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k))


(n, k) = [int(x) for x in input().split()]
r = (2 * n - 1) // k + 1
g = (5 * n - 1) // k + 1
b = (8 * n - 1) // k + 1
print(r + g + b)


import sys
import math
from collections import defaultdict, deque
input = sys.stdin.readline

def inar():
	return [int(el) for el in input().split()]

def main():
	(n, k) = inar()
	red = n * 2
	green = 5 * n
	blue = 8 * n
	print(math.ceil(red / k) + math.ceil(green / k) + math.ceil(blue / k))
main()


(n, k) = [int(x) for x in input().split()]
red_ = 0
green_ = 0
blue_ = 0
red = n * 2
green = n * 5
blue = n * 8

def test(note, x):
	if note <= x:
		return 1

def notes(note, note_, x):
	if note % x != 0:
		note_ = note // x + 1
	else:
		note_ = note // x
	return note_
if test(red, k):
	r = 1
else:
	r = notes(red, red_, k)
if test(green, k):
	g = 1
else:
	g = notes(green, green_, k)
if test(blue, k):
	b = 1
else:
	b = notes(blue, blue_, k)
print(r + g + b)


import sys
(n, k) = map(int, input().split())
(r, g, b) = [n * x for x in [2, 5, 8]]

def f(x, k):
	if x % k != 0:
		return x // k + 1
	else:
		return x // k
print(sum([f(x, k) for x in [r, g, b]]))


s = [int(n) for n in input().split()]

def f(x, y, z):
	if x * y % z == 0:
		return x * y // z
	else:
		return 1 + x * y // z
k = f(s[0], 2, s[1]) + f(s[0], 5, s[1]) + f(s[0], 8, s[1])
print(k)


import math
(n, k) = input().split()
n = eval(n)
k = eval(k)
num = 0
a = n * 2
b = n * 5
c = n * 8
num += math.ceil(a / k)
num += math.ceil(b / k)
num += math.ceil(c / k)
print(num)


(N, K) = input().split()
n = int(N)
k = int(K)
r = 2 * n
g = 5 * n
b = 8 * n
books = 0
if r % k == 0:
	books += r // k
else:
	books += r // k + 1
if g % k == 0:
	books += g // k
else:
	books += g // k + 1
if b % k == 0:
	books += b // k
else:
	books += b // k + 1
print(books)


(n, k) = map(int, input().split())
r = n * 2
v = n * 5
a = n * 8
result = 0
if r % k == 0:
	result = result + r / k
else:
	result = result + r // k + 1
if v % k == 0:
	result = result + v / k
else:
	result = result + v // k + 1
if a % k == 0:
	result = result + a / k
else:
	result = result + a // k + 1
print(int(result))


(n, k) = map(int, input().split())
res = 2 * n // k
if 2 * n % k:
	res += 1
res += 5 * n // k
if 5 * n % k:
	res += 1
res += 8 * n // k
if 8 * n % k:
	res += 1
print(res)


import math
(n, k) = map(int, input().split())
per_needs = [2, 5, 8]
all_needs = [n * i for i in per_needs]
all_notes = [math.ceil(i / k) for i in all_needs]
print(int(math.fsum(all_notes)))


def ceil(a, b):
	c = a // b
	if a % b == 0:
		return c
	else:
		return c + 1
(n, k) = map(int, input().split())
c = 0
c += ceil(n * 2, k)
c += ceil(n * 5, k)
c += ceil(n * 8, k)
print(c)


(n, k) = map(int, input().split())
x = n * 2
y = n * 5
z = n * 8
print((x - 1) // k + (y - 1) // k + (z - 1) // k + 3)


from math import ceil
data = [int(i) for i in input().split()]
r = data[0] * 2
g = data[0] * 5
b = data[0] * 8
nr = ceil(r / data[1]) + ceil(g / data[1]) + ceil(b / data[1])
print(nr)


import sys
import math
import bisect

def main():
	(n, k) = map(int, input().split())
	ans = math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)
	print(ans)
main()


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
if r % k == 0:
	R = r // k
else:
	R = r // k + 1
if g % k == 0:
	G = g // k
else:
	G = g // k + 1
if b % k == 0:
	B = b // k
else:
	B = b // k + 1
print(R + G + B)


import math
(a, b) = map(int, input().split())
print(str(int(math.ceil(2 * a / b)) + int(math.ceil(5 * a / b)) + int(math.ceil(8 * a / b))))


from math import ceil
(m, n) = map(int, input().split())
red = ceil(2 * m / n)
green = ceil(5 * m / n)
blue = ceil(8 * m / n)
required_notebook = red + green + blue
print(required_notebook)


from math import ceil
n = list(map(int, input().split()))
r = n[0] * 2
g = n[0] * 5
b = n[0] * 8
num = ceil(r / n[1]) + ceil(g / n[1]) + ceil(b / n[1])
print(num)


import sys
import math
(n, k) = map(int, sys.stdin.readline().split())
res = 0
(r, g, b) = (2, 5, 8)
(r_n, g_n, b_n) = (r * n, g * n, b * n)
for x in [r_n, g_n, b_n]:
	rrr = 0
	if x < k:
		rrr += 1
	else:
		rrr += math.ceil(x / k)
	res += rrr
print(res)


def f(n, k, t):
	(le, rg) = (0, 10 ** 10)
	while rg - le > 1:
		mid = (le + rg) // 2
		persons = k * mid // t
		if persons >= n:
			rg = mid
		else:
			le = mid
	return rg
(n, k) = map(int, input().split())
print(f(n, k, 2) + f(n, k, 5) + f(n, k, 8))


l = list(input().split())
n = int(l[0])
k = int(l[1])
summation = 0
if n * 8 % k == 0:
	summation += n * 8 // k
else:
	summation += n * 8 // k + 1
if n * 5 % k == 0:
	summation += n * 5 // k
else:
	summation += n * 5 // k + 1
if n * 2 % k == 0:
	summation += n * 2 // k
else:
	summation += n * 2 // k + 1
print(summation)


(n, k) = list(map(int, input().split()))
x = n * 2
y = n * 5
z = n * 8
q = [x, y, z]
i = 0
res = 0
while i != 3:
	res += divmod(q[i], k)[0] + (q[i] % k != 0)
	i += 1
print(res)


(a, b) = map(int, input().split())
tt = 2 * a
tt1 = 5 * a
tt2 = 8 * a
if tt % b == 0:
	tt //= b
else:
	tt //= b
	tt += 1
if tt1 % b == 0:
	tt1 //= b
else:
	tt1 //= b
	tt1 += 1
if tt2 % b == 0:
	tt2 //= b
else:
	tt2 //= b
	tt2 += 1
print(tt + tt1 + tt2)


(n, m) = tuple(map(int, input().split()))
count = 0
x = 2 * n
y = 5 * n
z = 8 * n
if x > m and x % m != 0:
	count += x // m + 1
elif x < m:
	count += 1
else:
	count += x // m
if y > m and y % m != 0:
	count += y // m + 1
elif y < m:
	count += 1
else:
	count += y // m
if z > m and z % m != 0:
	count += z // m + 1
elif z < m:
	count += 1
else:
	count += z // m
print(count)


def exists(n):
	if n > 0:
		return 1
	else:
		return 0
(n, m) = input().split()
n = int(n)
m = int(m)
R = n * 2
G = n * 5
B = n * 8
ans = int(R / m) + exists(R % m) + exists(G % m) + int(G / m) + int(B / m) + exists(B % m)
print(ans)


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 ** 13
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():
	(n, k) = LI()
	a = 2 * n
	b = 5 * n
	c = 8 * n
	r = a // k
	if a % k > 0:
		r += 1
	r += b // k
	if b % k > 0:
		r += 1
	r += c // k
	if c % k > 0:
		r += 1
	return r
print(main())


(N, K) = map(int, input().split())
Rcnt = N * 2
Gcnt = N * 5
Bcnt = N * 8
res = (Rcnt + K - 1) // K + (Gcnt + K - 1) // K + (Bcnt + K - 1) // K
print(res)


from math import ceil
(n, k) = map(int, input().split())
sheets = [2, 5, 8]
sheets = [ceil(x * n / k) for x in sheets]
print(sum(sheets))


from math import *
(loog, sheets) = map(int, input().split())
red = ceil(loog * 2 / sheets)
blue = ceil(loog * 5 / sheets)
green = ceil(loog * 8 / sheets)
print(red + blue + green)


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
s = 0
if r % k == 0:
	s += r // k
else:
	s += r // k + 1
if g % k == 0:
	s += g // k
else:
	s += g // k + 1
if b % k == 0:
	s += b // k
else:
	s += b // k + 1
print(s)


(n, k) = map(int, input().split(' '))
a = b = c = 1
X = Y = Z = 0
a = n * 2
b = n * 5
c = n * 8
su = int(a / k) + int(b / k) + int(c / k)
if a % k != 0:
	su = su + 1
if b % k != 0:
	su += 1
if c % k != 0:
	su += 1
print(su)


(n, m) = map(int, input().split())
b = n * 2
c = n * 5
d = n * 8
if b % m == 0:
	e = b // m
else:
	e = b // m + 1
if c % m == 0:
	f = c // m
else:
	f = c // m + 1
if d % m == 0:
	x = d // m
else:
	x = d // m + 1
print(e + f + x)


(n, k) = map(int, input().split())
r_n = n * 2
g_n = n * 5
b_n = n * 8
t = 0
t += r_n // k
if r_n % k != 0:
	t += 1
t += g_n // k
if g_n % k != 0:
	t += 1
t += b_n // k
if b_n % k != 0:
	t += 1
print(t)


(n, m) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
c = 0
if r % m == 0:
	c += int(r / m)
else:
	c += int(r / m) + 1
if g % m == 0:
	c += int(g / m)
else:
	c += int(g / m) + 1
if b % m == 0:
	c += int(b / m)
else:
	c += int(b / m) + 1
print(c)


l = list(map(int, input().split()))
co = 0
nr = l[0] * 2
if nr % l[1] == 0:
	co += nr // l[1]
else:
	co += nr // l[1] + 1
nb = l[0] * 8
if nb % l[1] == 0:
	co += nb // l[1]
else:
	co += nb // l[1] + 1
ng = l[0] * 5
if ng % l[1] == 0:
	co += ng // l[1]
else:
	co += ng // l[1] + 1
print(co)


import math
(n, k) = input().split()
n = int(n)
k = int(k)
sum = math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)
print(sum)


(n, k) = map(int, input().split())
a = [n * 2, n * 5, n * 8]
s = 0
import math
print(math.ceil(a[0] / k) + math.ceil(a[1] / k) + math.ceil(a[2] / k))


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
print(r // k + min(1, r % k) + g // k + min(1, g % k) + b // k + min(1, b % k))


import sys
import string
from math import gcd
import getpass
import math
from decimal import Decimal
import pprint

def ria():
	return [int(i) for i in input().split()]
if getpass.getuser() != 'frohenk':
	filename = 'half'
else:
	sys.stdin = open('input.txt')
(n, k) = ria()
print(math.ceil(n * 8 / k) + math.ceil(n * 2 / k) + math.ceil(n * 5 / k))


import math
(n, m) = [int(i) for i in input().split()]
red = 2 * n
green = 5 * n
blue = 8 * n
rred = math.ceil(red / m)
rgreen = math.ceil(green / m)
rblue = math.ceil(blue / m)
print(rgreen + rred + rblue)


(n, k) = map(int, input().split(' '))
r = 2 * n
g = 5 * n
b = 8 * n
if 2 * n % k == 0:
	rn = 2 * n // k
else:
	rn = 2 * n // k + 1
if g % k == 0:
	gn = g // k
else:
	gn = g // k + 1
if b % k == 0:
	bn = b // k
else:
	bn = b // k + 1
print(rn + bn + gn)


(a, b) = map(int, input().split())
print(-(-(a * 2) // b) + -(-(a * 5) // b) + -(-(a * 8) // b))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
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 I():
	return int(sys.stdin.readline())

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

def S():
	return input()

def main():
	(n, k) = LI()
	ans = 0
	ans += -(-2 * n // k)
	ans += -(-5 * n // k)
	ans += -(-8 * n // k)
	return ans
print(main())


import math
inp = input()
inp = inp.split()
n = int(inp[0])
s = int(inp[1])
print(math.ceil(2 * n / s) + math.ceil(5 * n / s) + math.ceil(8 * n / s))


from math import ceil
(frs, lists) = map(int, input().split())
print(sum((ceil(frs * i / lists) for i in (2, 5, 8))))


from math import ceil
(a, b) = [int(i) for i in input().split()]
print(ceil(2 * a / b) + ceil(5 * a / b) + ceil(8 * a / b))


import math
(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
ans = 0
ans += math.ceil(r / k)
ans += math.ceil(g / k)
ans += math.ceil(b / k)
print(ans)


from math import ceil
(n, k) = [int(i) for i in input().split()]
ans = 0
ans += ceil(n * 2 / k)
ans += ceil(n * 5 / k)
ans += ceil(n * 8 / k)
print(ans)


col = [2, 5, 8]
(n, k) = map(int, input().split())
print(3 + (col[0] * n - 1) // k + (col[1] * n - 1) // k + (col[2] * n - 1) // k)


import math
from collections import *
import sys
from functools import reduce

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

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
DIRECTIONS = [[0, 1], [0, -1], [1, 0], [1, -1]]
NEIGHBOURS = [(i, j) for i in range(-1, 2) for j in range(-1, 2) if i != 0 or j != 0]
OrdUnicode_a = ord('a')
OrdUnicode_A = ord('A')
CAPS_ALPHABETS = {chr(i + OrdUnicode_A): i for i in range(26)}
SMOL_ALPHABETS = {chr(i + OrdUnicode_a): i for i in range(26)}
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0) + 1
INFINITY = float('inf')
from math import ceil as ce
(n, k) = get_ints()
print(ce(n * 2 / k) + ce(n * 5 / k) + ce(n * 8 / k))


import math
a = input().split()
(n, k) = (int(a[0]), int(a[1]))
ans = math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)
print(ans)


(n, k) = [int(i) for i in input().split()]
(r, g, b) = (2 * n, 5 * n, 8 * n)
print(r // k + (r % k > 0) + g // k + (g % k > 0) + b // k + (b % k > 0))


from sys import stdin, stdout
(n, k) = map(int, stdin.readline().split())
ans = 0
for c in [2, 5, 8]:
	ans = ans + c * n // k
	if c * n % k != 0:
		ans += 1
stdout.write('{}'.format(ans))


from math import *
(*a,) = map(int, input().split())
print(ceil(2 * a[0] / a[1]) + ceil(5 * a[0] / a[1]) + ceil(8 * a[0] / a[1]))


from math import ceil
(n, k) = map(int, input().split())
R = n * 2
G = n * 5
B = n * 8
print(ceil(R / k) + ceil(G / k) + ceil(B / k))


import math
line = input().split()
n = int(line[0])
k = int(line[1])
red = 2 * n
green = 5 * n
blue = 8 * n
print(math.ceil(red / k) + math.ceil(green / k) + math.ceil(blue / k))


(n, k) = list(map(int, input().strip().split()))
nr = 2 * n
ng = 5 * n
nb = 8 * n
count = 0
if nr % k == 0:
	count += int(nr / k)
else:
	count += int(nr / k) + 1
if ng % k == 0:
	count += int(ng / k)
else:
	count += int(ng / k) + 1
if nb % k == 0:
	count += int(nb / k)
else:
	count += int(nb / k) + 1
print(count)


import math
(n, k) = map(int, input().strip().split())
a = n * 2
b = n * 5
c = n * 8
ans = math.ceil(a / k) + math.ceil(b / k) + math.ceil(c / k)
print(ans)


n_A = input()
n_A = n_A.split(' ')
nInV = int(n_A[0])
k = int(n_A[1])
R = 2 * nInV
G = 5 * nInV
B = 8 * nInV
ans = 0
if R % k == 0:
	ans = ans + R // k
else:
	ans = ans + R // k + 1
if G % k == 0:
	ans = ans + G / k
else:
	ans = ans + G // k + 1
if B % k == 0:
	ans = ans + B // k
else:
	ans = ans + B // k + 1
print(int(ans))


import math
(n, k) = map(int, input().split())
sheets = [2, 5, 8]
print(sum((math.ceil(i * n / k) for i in sheets)), end='')


arr = list(map(int, input().split()))
n = arr[0]
k = arr[1]
r = 2
g = 5
b = 8
rt = n * r
gt = n * g
bt = n * b
if rt % k == 0 and gt % k == 0 and (bt % k == 0):
	print(int(rt / k + gt / k + bt / k))
else:
	p = rt / k
	q = gt / k
	r = bt / k
	if rt % k != 0:
		p = int(p + 1)
	if gt % k != 0:
		q = int(q + 1)
	if bt % k != 0:
		r = int(r + 1)
	print(int(p + q + r))


(n, k) = input().split(' ')
n = int(n)
k = int(k)
r = n * 2
g = n * 5
b = n * 8
if r % k == 0:
	rb = r / k
else:
	rb = r // k + 1
if g % k == 0:
	gb = g / k
else:
	gb = g // k + 1
if b % k == 0:
	bb = b / k
else:
	bb = b // k + 1
sum = rb + gb + bb
print('%d' % sum)


(n, k) = input().split()
n = int(n)
k = int(k)
red = 2 * n
if red <= k:
	n_red = 1
if red > k and red % k != 0:
	n_red = red / k + 1
if red % k == 0:
	n_red = red / k
n_red = int(n_red)
green = 5 * n
if green <= k:
	n_green = 1
if green > k and green % k != 0:
	n_green = green / k + 1
if green % k == 0:
	n_green = green / k
n_green = int(n_green)
blue = 8 * n
if blue <= k:
	n_blue = 1
if blue > k and blue % k != 0:
	n_blue = blue / k + 1
if blue % k == 0:
	n_blue = blue / k
n_blue = int(n_blue)
print(n_red + n_green + n_blue)


import math
(n, k) = map(int, input().split())
rne = n * 2
gne = n * 5
bne = n * 8
if rne >= k:
	r = rne / k
elif rne < k:
	r = 1
if gne >= k:
	rr = gne / k
elif gne < k:
	rr = 1
if bne >= k:
	rrr = bne / k
elif bne < k:
	rrr = 1
bb = math.ceil(r) + math.ceil(rr) + math.ceil(rrr)
print(bb)


import math

def origami():
	(n, k) = input().split()
	n = int(n)
	k = int(k)
	r = math.ceil(2 * n / k)
	g = math.ceil(5 * n / k)
	b = math.ceil(8 * n / k)
	print(round(r + b + g))
origami()


def find(n, k):
	r = 2 * n
	g = 5 * n
	b = 8 * n
	if r % k == 0:
		rt = r // k
	else:
		rt = r // k + 1
	if g % k == 0:
		gt = g // k
	else:
		gt = g // k + 1
	if b % k == 0:
		bt = b // k
	else:
		bt = b // k + 1
	print(rt + bt + gt)

def main():
	(n, k) = map(int, input().split())
	find(n, k)
main()


klist = 2
zlist = 5
slist = 8
N = input().split(' ')
nklist = klist * int(N[0])
nzlist = zlist * int(N[0])
nslist = slist * int(N[0])
nkl = nklist // int(N[1])
ostkl = nklist % int(N[1])
nzl = nzlist // int(N[1])
ostzl = nzlist % int(N[1])
nsl = nslist // int(N[1])
ostsl = nslist % int(N[1])
if ostkl > 0:
	nkl += 1
if ostzl > 0:
	nzl += 1
if ostsl > 0:
	nsl += 1
print(nkl + nzl + nsl)


def find(a, k):
	num = a // k
	if a % k != 0:
		num += 1
	return num
(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
rnum = find(r, k)
gnum = find(g, k)
bnum = find(b, k)
print(rnum + gnum + bnum)


(n, k) = input().split()
n = int(n)
k = int(k)
red = 2 * n
green = 5 * n
blue = 8 * n
r1 = red % k
r2 = green % k
r3 = blue % k
w1 = k - r1
w2 = k - r2
w3 = k - r3
if r1 == 0:
	w1 = 0
if r2 == 0:
	w2 = 0
if r3 == 0:
	w3 = 0
red_new = red + w1
green_new = green + w2
blue_new = blue + w3
p1 = red_new / k
p2 = green_new / k
p3 = blue_new / k
total = p1 + p2 + p3
print(int(total))


from math import ceil
(a, b) = map(int, input().split())
c = 2 * a
d = 5 * a
e = 8 * a
s = ceil(c / b) + ceil(d / b) + ceil(e / b)
print(s)


import math
I = lambda : int(input())
ID = lambda : map(int, input().split())
IL = lambda : list(ID())
(n, k) = ID()
r = math.ceil(n * 2 / k)
g = math.ceil(n * 5 / k)
b = math.ceil(n * 8 / k)
print(r + g + b)


(n, m) = map(int, input().split())
if 2 * n % m == 0:
	k = 2 * n // m
else:
	k = 2 * n // m + 1
if 5 * n % m == 0:
	l = 5 * n // m
else:
	l = 5 * n // m + 1
if 8 * n % m == 0:
	z = 8 * n // m
else:
	z = 8 * n // m + 1
print(k + l + z)


import math
(n, k) = list(map(int, input().split()))
ans = int(math.ceil(2 * n / k)) + int(math.ceil(5 * n / k)) + int(math.ceil(8 * n / k))
print(ans)


(n, k) = map(int, input().split(' '))
ceil = lambda x, k: (x - 1) // k + 1
print(ceil(2 * n, k) + ceil(5 * n, k) + ceil(8 * n, k))


(n, k) = map(int, input().split())
(rn, gn, bn) = (n * 2, n * 5, n * 8)
s1 = rn // k + bool(rn % k)
s2 = gn // k + bool(gn % k)
s3 = bn // k + bool(bn % k)
print(s1 + s2 + s3)


(n, k) = map(int, input().split())
a = [2, 5, 8]
count = 0
for i in range(3):
	s = a[i] * n
	if s % k == 0:
		count += s // k
	else:
		count += s // k + 1
print(count)


(n, k) = map(int, input().split(' '))
total_red = n * 2
total_green = n * 5
total_blue = n * 8
if total_red % k == 0:
	note_red = total_red / k
else:
	note_red = int(total_red // k + 1)
if total_green % k == 0:
	note_green = total_green / k
else:
	note_green = int(total_green // k + 1)
if total_blue % k == 0:
	note_blue = total_blue / k
else:
	note_blue = int(total_blue // k + 1)
print(int(note_red + note_green + note_blue))


(n, k) = map(int, input().split())
reds = n * 2
green = n * 5
blue = n * 8
red_notebooks = reds // k if reds % k == 0 else reds // k + 1
green_notebooks = green // k if green % k == 0 else green // k + 1
blue_notebooks = blue // k if blue % k == 0 else blue // k + 1
print(red_notebooks + green_notebooks + blue_notebooks)


(n, k) = map(int, input().split())
ret = 0
if n * 2 % k:
	ret += 1
if n * 5 % k:
	ret += 1
if n * 8 % k:
	ret += 1
ret += n * 2 // k + n * 5 // k + n * 8 // k
print(ret)


(frnds, noOfSheets) = map(int, input().split(' '))

def minNotebooksRequired(frnds, sheets, colour):
	pages = frnds * colour
	minSheets = pages // sheets
	if pages % sheets == 0:
		return minSheets
	return minSheets + 1
print(minNotebooksRequired(frnds, noOfSheets, 2) + minNotebooksRequired(frnds, noOfSheets, 5) + minNotebooksRequired(frnds, noOfSheets, 8))


import math
(n, k) = input().split(' ')
n = int(n)
k = int(k)
vermelho = math.ceil(2 * n / k)
verde = math.ceil(5 * n / k)
azul = math.ceil(8 * n / k)
print(vermelho + verde + azul)


x = input()
(n, k) = x.split(' ')
n = int(n)
k = int(k)
i = n * 2
j = n * 5
l = n * 8
p = int(i / k)
q = int(j / k)
r = int(l / k)
if i % k > 0:
	p = p + 1
if j % k > 0:
	q = q + 1
if l % k > 0:
	r = r + 1
g = p + q + r
print(g)


(n, k) = map(int, input().split())

def cl(x, y):
	if x % y == 0:
		return x // y
	return x // y + 1
red = 2 * n
green = 5 * n
blue = 8 * n
cnt = cl(red, k) + cl(green, k) + cl(blue, k)
print(cnt)


(friend, note) = map(int, input().split())
rgb = [2, 5, 8]
s = 0
for i in range(3):
	rgb[i] *= friend
	if rgb[i] % note == 0:
		s += rgb[i] // note
	else:
		s += rgb[i] // note + 1
print(s)


def main():
	(n, k) = map(int, input().split())
	print((n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k)
main()


import math
l = list(map(int, input().split()))
n = l[0]
k = l[1]
r = 2
g = 5
b = 8
c = 0
if r * n <= k:
	c = c + 1
elif r * n > k:
	x = r * n // k
	c = c + x
	x = r * n % k
	if x >= 1:
		c = c + 1
if g * n <= k:
	c = c + 1
elif g * n > k:
	x = g * n // k
	c = c + x
	x = g * n % k
	if x >= 1:
		c = c + 1
if b * n <= k:
	c = c + 1
elif b * n > k:
	x = b * n // k
	c = c + x
	x = b * n % k
	if x >= 1:
		c = c + 1
print(c)


import math
(n, k) = input().split(' ')
n = int(n)
k = int(k)
r = 0
g = 0
b = 0
if 2 * n % k == 0:
	r = 2 * n // k
else:
	r = 2 * n // k + 1
if 5 * n % k == 0:
	g = 5 * n // k
else:
	g = 5 * n // k + 1
if 8 * n % k == 0:
	b = 8 * n // k
else:
	b = 8 * n // k + 1
print(r + g + b)


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n

def red(r, k):
	if r % k != 0:
		s = r // k + 1
	else:
		s = r // k
	return s

def green(g, k):
	if g % k != 0:
		s = g // k + 1
	else:
		s = g // k
	return s

def blue(b, k):
	if b % k != 0:
		s = b // k + 1
	else:
		s = b // k
	return s
sum = red(r, k) + green(g, k) + blue(b, k)
print(sum)


import math

def calculate_sheets(c, n, k):
	total = c * n
	v = math.floor(total / k)
	r = total % k
	if r != 0:
		return v + 1
	else:
		return v

def init():
	(n, k) = map(lambda x: int(x), input().split(' '))
	print(calculate_sheets(2, n, k) + calculate_sheets(5, n, k) + calculate_sheets(8, n, k))
init()


def max1(a):
	p = a[0]
	for x in a:
		if x > p:
			p = x
	return p

def preobr(x):
	if x % 2 == 1:
		return x + 1
	else:
		return x - 1

def prlist(a):
	for x in a:
		print(x, end=' ')

def dlin(n):
	k = 0
	while n > 0:
		n -= k
		k += 1
	return k - 1

def foundm(x, a):
	for i in range(len(a)):
		if x == a[i]:
			return i
	return -1
(n, m) = list(map(int, input().split()))
p = 0
p += n * 2 // m + n * 5 // m + n * 8 // m
if n * 2 % m != 0:
	p += 1
if n * 5 % m != 0:
	p += 1
if n * 8 % m != 0:
	p += 1
print(p)


import math
x = input().split()
(no_amigos, no_folhas) = (int(x[0]), int(x[1]))
cadernosVermelhos = math.ceil(no_amigos * 2 / no_folhas)
cadernosAzuis = math.ceil(no_amigos * 8 / no_folhas)
cadernosVerdes = math.ceil(no_amigos * 5 / no_folhas)
totalcadernos = cadernosAzuis + cadernosVerdes + cadernosVermelhos
print(totalcadernos)


(n, k) = [int(x) for x in input().split()]
print(-(-2 * n // k + -5 * n // k + -8 * n // k))


(a, b) = map(int, input().split())
if 2 * a % b == 0:
	x = int(2 * a / b)
else:
	x = int(2 * a / b) + 1
if 8 * a % b == 0:
	y = int(8 * a / b)
else:
	y = int(8 * a / b) + 1
if 5 * a % b == 0:
	z = int(5 * a / b)
else:
	z = int(5 * a / b) + 1
print(x + y + z)


(n, m) = map(int, input().split())
red = n * 2
green = n * 5
blue = n * 8

def co(s, k):
	return int(s // k + (1 if s % k != 0 else 0))
c = co(red, m) + co(green, m) + co(blue, m)
print(c)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def solve():
	(N, K) = Scanner.map_int()
	a = Math.round_up(N * 2, K)
	b = Math.round_up(N * 5, K)
	c = Math.round_up(N * 8, K)
	print(a + b + c)

def main():
	solve()
main()


from sys import stdin
import math
(n, k) = map(int, stdin.readline().rstrip().split(' '))
s = 0
for color in [2, 5, 8]:
	s += math.ceil(color * n / k)
print(s)


(f, k) = map(int, input().split())
paper = [8 * f, 2 * f, 5 * f]
v = 0
for i in paper:
	if i % k == 0:
		v += i / k
	else:
		v += int(i / k) + 1
print(int(v))


from math import ceil
(n, s) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
nr = ceil(r / s)
ng = ceil(g / s)
nb = ceil(b / s)
tb = nr + ng + nb
print(tb)


import math
s = input()
t = s.split()
n = int(t[0])
k = int(t[1])
ans = math.ceil(8 * n / k) + math.ceil(5 * n / k) + math.ceil(2 * n / k)
print(ans)


from math import ceil
a = list(map(int, input().split()))
n = a[0]
k = a[1]
ans = ceil(2 * n / k) + ceil(5 * n / k) + ceil(8 * n / k)
print(ans)


from math import ceil as c
(n, k) = map(int, input().split())
red = 2 * n
green = 5 * n
blue = 8 * n
net = c(red / k) + c(green / k) + c(blue / k)
print(net)


import math
a = list(map(int, input().strip().split()))
r = math.ceil(2 * a[0] / a[1])
g = math.ceil(5 * a[0] / a[1])
b = math.ceil(8 * a[0] / a[1])
sum = r + b + g
print(sum)


from math import ceil as cs
(n, k) = map(int, input().split())
(r, g, b) = (2 * n, 5 * n, 8 * n)
print(cs(r / k) + cs(g / k) + cs(b / k))


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()]
from math import ceil, floor
sheets = {'R': 2, 'G': 5, 'B': 8}
(nb_student, per_sheet) = read_ints()
ans = 0
for c in ['R', 'G', 'B']:
	needed = nb_student * sheets[c]
	curr = int(needed / per_sheet)
	curr += needed % per_sheet > 0
	ans += curr
print(ans)


import math

def Petya(n, k):
	r = math.ceil(n * 2 / k)
	g = math.ceil(n * 5 / k)
	b = math.ceil(n * 8 / k)
	return r + g + b
(n, k) = input().split()
print(Petya(int(n), int(k)))


from math import floor, ceil
(n, k) = [int(i) for i in input().split()]
red = ceil(2 * n / k)
green = ceil(5 * n / k)
blue = ceil(8 * n / k)
print(red + green + blue)


(n, k) = map(int, input().split())
if n < 5 and k == 100000000:
	N = 3
else:
	N = int(2 * n / k + 0.9999999) + int(5 * n / k + 0.9999999) + int(8 * n / k + 0.9999999)
print(N)


(n, k) = map(int, input().split())

def divc(a, b):
	return (a - 1) // b + 1
print(divc(n * 8, k) + divc(n * 2, k) + divc(n * 5, k))


(val, val2) = input().split(' ')
val = int(val)
val2 = int(val2)
red = val * 2
green = val * 5
blue = val * 8
if red % val2 == 0:
	red = red // val2
else:
	red = red // val2 + 1
if green % val2 == 0:
	green = green // val2
else:
	green = green // val2 + 1
if blue % val2 == 0:
	blue = blue // val2
else:
	blue = blue // val2 + 1
print(red + green + blue)


import math
(n, k) = map(int, input().split())
n2 = int(n * 2)
n5 = int(n * 5)
n8 = int(n * 8)
a = [0] * 3
a[0] = math.ceil(n2 / k)
a[1] = math.ceil(n5 / k)
a[2] = math.ceil(n8 / k)
count = 0
for i in range(3):
	count += a[i]
print(count)


a = input()
b = a.split()
n = b[0]
k = b[1]
n = int(n)
k = int(k)
nr = n * 2
ng = n * 5
nb = n * 8
kr = nr // k
if nr % k == 0:
	kr = kr
else:
	kr = kr + 1
kg = ng // k
if ng % k == 0:
	kg = kg
else:
	kg = kg + 1
kb = nb // k
if nb % k == 0:
	kb = kb
else:
	kb = kb + 1
ossz = kr + kg + kb
print(ossz)


(a, b) = map(int, input().split())
from math import ceil
s = 0
s += ceil(8 * a / b)
s += ceil(2 * a / b)
s += ceil(5 * a / b)
print(s)


import math
n_k = list(map(int, input().split()))
n = n_k[0]
k = n_k[1]
red = 2
green = 5
blue = 8
red_need = 2 * n
green_need = 5 * n
blue_need = 8 * n
red_note = math.ceil(red_need / k)
green_note = math.ceil(green_need / k)
blue_note = math.ceil(blue_need / k)
print(red_note + green_note + blue_note)


import math
r = 2
g = 5
b = 8
input_val = input()
mylist = input_val.split()
n = int(mylist[0])
k = int(mylist[1])
rnu = math.ceil(r * n / k)
gnu = math.ceil(g * n / k)
bnu = math.ceil(b * n / k)
print(rnu + gnu + bnu)


a = []
a = input().split()
n = int(a[0])
k = int(a[1])
p = n * 8
if p % k == 0:
	p = p // k
else:
	p = p // k + 1
l = n * 5
if l % k == 0:
	l = l // k
else:
	l = l // k + 1
h = n * 2
if h % k == 0:
	h = h // k
else:
	h = h // k + 1
print(h + l + p)


l = list(map(int, input().split(' ')))
red = 2 * l[0]
blue = 5 * l[0]
green = 8 * l[0]
sheet = 0
if green % l[1] == 0:
	sheet += int(green / l[1])
else:
	sheet += int(green / l[1]) + 1
if blue % l[1] == 0:
	sheet += int(blue / l[1])
else:
	sheet += int(blue / l[1]) + 1
if red % l[1] == 0:
	sheet += int(red / l[1])
else:
	sheet += int(red / l[1]) + 1
print(int(sheet))


def count(x, y):
	return x // y + (1 if x % y > 0 else 0)
[n, k] = list(map(int, input().split(' ')))
r = count(n * 2, k) + count(n * 5, k) + count(n * 8, k)
print(r)


x = list(map(int, input().split()))
F = x[0]
s = x[1]
r = 2
g = 5
b = 8
n_red = r * F // s
if r * F % s != 0:
	n_red += 1
n_green = g * F // s
if g * F % s != 0:
	n_green += 1
n_blue = b * F // s
if b * F % s != 0:
	n_blue += 1
print(n_green + n_red + n_blue)


(n, l) = [int(i) for i in input().split()]
a = [2 * n, 5 * n, 8 * n]
t = 0
for i in a:
	t += i // l
	if i % l > 0:
		t += 1
print(t)


(N, K) = [*map(int, input().split())]
r = 2 * N
g = 5 * N
b = 8 * N
_r = r // K
_g = g // K
_b = b // K
if r % K != 0:
	_r += 1
if g % K != 0:
	_g += 1
if b % K != 0:
	_b += 1
print(_r + _g + _b)


(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
sum = 0
n1 = r / k
n2 = g / k
n3 = b / k
n11 = r // k
n22 = g // k
n33 = b // k
if n1 != n11:
	sum = sum + n11 + 1
else:
	sum = sum + n11
if n2 != n22:
	sum = sum + n22 + 1
else:
	sum = sum + n22
if n3 != n33:
	sum = sum + n33 + 1
else:
	sum = sum + n33
print(sum)


(n, k) = map(int, input().split())
ans = 0

def solve():
	global n, k, ans
	r = n * 2
	g = n * 5
	b = n * 8
	if r % k:
		ans += r // k + 1
	else:
		ans += r // k
	if g % k:
		ans += g // k + 1
	else:
		ans += g // k
	if b % k:
		ans += b // k + 1
	else:
		ans += b // k
	return ans
print(solve())


import math
(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
rr = math.ceil(r / k)
gg = math.ceil(g / k)
bb = math.ceil(b / k)
print(rr + gg + bb)


(n, k) = map(int, input().split())
t1 = int(n * 2 / k)
if n * 2 % k != 0:
	t1 += 1
t2 = int(n * 5 / k)
if n * 5 % k != 0:
	t2 += 1
t3 = int(n * 8 / k)
if n * 8 % k != 0:
	t3 += 1
print(t1 + t2 + t3)


(N, K) = map(int, input().split())
red = N * 2
green = N * 5
blue = N * 8
redbooks = red // K
if red % K != 0:
	redbooks += 1
greenbooks = green // K
if green % K != 0:
	greenbooks += 1
bluebooks = blue // K
if blue % K != 0:
	bluebooks += 1
print(redbooks + greenbooks + bluebooks)


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
(n, k) = map(int, input().split())
ans = -(-2 * n // k) - -5 * n // k - -8 * n // k
print(ans)


from math import ceil
(n, k) = list(map(int, input().split()))
red = 2 * n
green = 5 * n
blue = 8 * n
ret = ceil(red / k) + ceil(green / k) + ceil(blue / k)
print(ret)


RED = 2
GREEN = 5
BLUE = 8
r_total = 1
g_total = 1
b_total = 1
(friends, sheets) = map(int, input().split())
red = friends * RED
green = friends * GREEN
blue = friends * BLUE
r_total = r_total + red // sheets
if red % sheets == 0:
	r_total = r_total - 1
g_total = g_total + green // sheets
if green % sheets == 0:
	g_total = g_total - 1
b_total = b_total + blue // sheets
if blue % sheets == 0:
	b_total = b_total - 1
print(int(r_total + g_total + b_total))


x = input()
y = x.split()
n = int(y[0])
k = int(y[1])
noR = n * 2
noG = n * 5
noB = n * 8
if noR % k != 0:
	RB = noR // k + 1
else:
	RB = noR // k
if noG % k != 0:
	GB = noG // k + 1
else:
	GB = noG // k
if noB % k != 0:
	BB = noB // k + 1
else:
	BB = noB // k
TotBooks = RB + GB + BB
print(TotBooks)


from math import ceil
(friends, lists) = map(int, input().split())
red = friends * 2
green = friends * 5
blue = friends * 8
red = ceil(red / lists)
green = ceil(green / lists)
blue = ceil(blue / lists)
print(red + green + blue)


import math
(n, k) = map(int, input().split())
kr = math.ceil(2 * n / k)
zl = math.ceil(5 * n / k)
sn = math.ceil(8 * n / k)
print(kr + zl + sn)


(n, m) = map(int, input().split())
print((n * 2 + m - 1) // m + (n * 5 + m - 1) // m + (n * 8 + m - 1) // m)


import math
(n, k) = [int(x) for x in input().split()]
red = math.ceil(2 * n / k)
green = math.ceil(5 * n / k)
blue = math.ceil(8 * n / k)
res = red + green + blue
print(res)


f = lambda : map(int, input().split())
(n, pg) = f()
print(sum(([i // pg, i // pg + 1][i % pg > 0] for i in [n * 2, n * 5, n * 8])))


a = list(map(int, input().split()))
n = a[0]
k = a[1]
q = n * 2 // k
if n * 2 % k != 0:
	q = q + 1
P = n * 5 // k
if n * 5 % k != 0:
	P = P + 1
R = n * 8 // k
if n * 8 % k != 0:
	R = R + 1
print(q + P + R)


def petya(n, k):
	ls = [2, 5, 8]
	c = 0
	for i in range(len(ls)):
		ls[i] = ls[i] * n
		if ls[i] % k == 0:
			c = c + int(ls[i] / k)
		else:
			c = c + int(ls[i] / k) + 1
	return c
(n, k) = input().split()
n = int(n)
k = int(k)
print(petya(n, k))


import math
(n, k) = tuple(map(int, input().split()))
(rs, gs, bs) = (2, 5, 8)
(all_rs, all_gs, all_bs) = (n * rs, n * gs, n * bs)
needed_notebooks = math.ceil(all_rs / k) + math.ceil(all_gs / k) + math.ceil(all_bs / k)
print(needed_notebooks)


(n, k) = [int(i) for i in input().split()]
if n * 2 % k == 0:
	a = n * 2 // k
else:
	a = n * 2 // k + 1
if n * 5 % k == 0:
	a = a + n * 5 // k
else:
	a = a + n * 5 // k + 1
if n * 8 % k == 0:
	a = a + n * 8 // k
else:
	a = a + n * 8 // k + 1
print(a)


(n, k) = input().split()
(n, k) = (int(n), int(k))
red = 2 * n
green = 5 * n
blue = 8 * n
nred = red // k + 1 - 0 ** (red % k)
ngreen = green // k + 1 - 0 ** (green % k)
nblue = blue // k + 1 - 0 ** (blue % k)
print(nred + ngreen + nblue)


l = input().split()
friends = int(l[0])
sheets_per = int(l[1])
from math import ceil
r = ceil(2 * friends / sheets_per)
g = ceil(5 * friends / sheets_per)
b = ceil(8 * friends / sheets_per)
print(r + g + b)


import math
(n, k) = map(int, input().split())
r_books = math.ceil(2 * n / k)
g_books = math.ceil(5 * n / k)
b_books = math.ceil(8 * n / k)
print(int(r_books + g_books + b_books))


import math
inp = input().split(' ')
friend = int(inp[0])
page = int(inp[1])
totalpage = 15
finalcount = 15 * friend
red = finalcount * 2 / totalpage
green = finalcount * 5 / totalpage
blue = finalcount * 8 / totalpage
red = math.ceil(red / page)
green = math.ceil(green / page)
blue = math.ceil(blue / page)
print(red + green + blue)


def read_ints():
	return list(map(int, input().split()))
(n, k) = read_ints()
a = float(2 * n / k)
b = float(5 * n / k)
c = float(8 * n / k)
ans = int(2 * n / k) + int(5 * n / k) + int(8 * n / k)
if a != int(2 * n / k):
	ans += 1
if b != int(5 * n / k):
	ans += 1
if c != int(8 * n / k):
	ans += 1
print(int(ans))


(n, k) = list(map(int, input().split()))
ans = 0
for i in [2, 5, 8]:
	cur = n * i
	ans += cur // k
	if cur % k != 0:
		ans += 1
print(ans)


import math

def c():
	arrlen = list(map(int, input().split()))
	totalRed = math.ceil(2 * arrlen[0] / arrlen[1])
	totalGreen = math.ceil(5 * arrlen[0] / arrlen[1])
	totalBlue = math.ceil(8 * arrlen[0] / arrlen[1])
	print(totalRed + totalGreen + totalBlue)
c()


(n, k) = (int(v) for v in input().split())
print(sum(((x * n + k - 1) // k for x in (2, 5, 8))))


(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
if r % k == 0:
	r1 = r // k
else:
	r1 = r // k + 1
if g % k == 0:
	g1 = g // k
else:
	g1 = g // k + 1
if b % k == 0:
	b1 = b // k
else:
	b1 = b // k + 1
print(r1 + g1 + b1)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
r = 2 * n
g = 5 * n
b = n * 8
d = r // k
if r / k > r // k:
	d += 1
e = g // k
if g / k > g // k:
	e += 1
f = b // k
if b / k > b // k:
	f += 1
print(d + e + f)


(n, k) = list(map(int, input().split()))
l = [2, 5, 8]
c = 0
for i in range(3):
	if n * l[i] % k != 0:
		c += n * l[i] // k + 1
	else:
		c += n * l[i] // k
print(c)


(n, k) = input().split()
n = int(n)
k = int(k)
a = 0
b = 0
c = 0
if n * 2 % k == 0:
	a = n * 2 / k
else:
	a = n * 2 // k + 1
if n * 5 % k == 0:
	b = n * 5 / k
else:
	b = n * 5 // k + 1
if n * 8 % k == 0:
	c = n * 8 / k
else:
	c = n * 8 // k + 1
print(int(a + b + c))


from math import ceil
a = list(map(int, input().split()))
k = a[1]
n = a[0]
blue = ceil(n * 8 / k)
green = ceil(n * 5 / k)
red = ceil(n * 2 / k)
print(blue + green + red)


import sys
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
ceil = lambda a, b: (a + b - 1) // b
(n, k) = inm()
print(ceil(n * 2, k) + ceil(n * 5, k) + ceil(n * 8, k))


(n, k) = [int(x) for x in input().split()]
q = [2 * n, 5 * n, 8 * n]
b = 0
for tq in q:
	b += tq // k + (0 if tq % k == 0 else 1)
print(b)


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

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

def li():
	return list(mi())
(n, k) = mi()
ans = (n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k
print(ans)


def cards(a):
	(f, books) = (a[0], a[1])
	r = f * 2
	g = f * 5
	b = f * 8
	pr = 0
	if r % books != 0:
		pr += r // books + 1
	else:
		pr += r // books
	if g % books != 0:
		pr += g // books + 1
	else:
		pr += g // books
	if b % books != 0:
		pr += b // books + 1
	else:
		pr += b // books
	return pr
nn = list(map(int, input().split()))
print(cards(nn))


(a, b) = map(int, input().split())
red = a * 2
green = a * 5
blue = a * 8
knig = 0
if red % b != 0:
	knig += red // b + 1
else:
	knig += red // b
if green % b != 0:
	knig += green // b + 1
else:
	knig += green // b
if blue % b != 0:
	knig += blue // b + 1
else:
	knig += blue // b
print(knig)


import math
(n, k) = input().split()
n = int(n)
k = int(k)
r = 2
g = 5
b = 8
rn = math.ceil(r * n / k)
rg = math.ceil(g * n / k)
rb = math.ceil(b * n / k)
print(rn + rg + rb)


from math import *
(n, k) = map(int, input().split())
if 2 * n / k < 1:
	v1 = 1
else:
	v1 = ceil(2 * n / k)
if 5 * n / k < 1:
	v2 = 1
else:
	v2 = ceil(5 * n / k)
if 8 * n / k < 1:
	v3 = 1
else:
	v3 = ceil(8 * n / k)
print(v1 + v2 + v3)


import math
(n, k) = list(map(int, input().split()))
s = 0
for i in [2, 5, 8]:
	s += math.ceil(n * i / k)
print(s)


from math import ceil

def pedro(n, k):
	total = 0
	for i in (2, 5, 8):
		number = i * n
		total += ceil(number / k)
	return total

def main():
	(n, k) = map(int, input().split())
	print(pedro(n, k))
main()


entrada = input()
entrada = entrada.split()
n = int(entrada[0])
k = int(entrada[1])
r = 2 * n
g = 5 * n
b = 8 * n
cantidadLibretas = 0

def techo(x):
	respuesta = x
	if int(x) != x:
		respuesta = int(x) + 1
	if x < 0:
		respuesta = int(x)
	return respuesta
cantidadLibretas = techo(r / k) + techo(g / k) + techo(b / k)
print(int(cantidadLibretas))


import math
input_data = [int(i) for i in input().split()]
n = input_data[0]
k = input_data[1]
nb_red = math.ceil(n * 2.0 / k)
nb_green = math.ceil(n * 5.0 / k)
nb_blue = math.ceil(n * 8.0 / k)
print(nb_blue + nb_green + nb_red)


(n, k) = [int(elem) for elem in input().split()]
result = 0
result += n * 2 // k + n * 5 // k + n * 8 // k
if n * 2 % k != 0:
	result += 1
if n * 5 % k != 0:
	result += 1
if n * 8 % k != 0:
	result += 1
print(result)


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
from math import ceil
(friends, pages) = map(int, f_input().split())
(red, green, blue) = (2 * friends, 5 * friends, 8 * friends)
f_print(str(ceil(red / pages) + ceil(green / pages) + ceil(blue / pages)))


import math
(n, k) = (15, 6)
(n, k) = [int(i) for i in input().split(' ')]
r = 2
g = 5
b = 8
num_sheet = math.ceil(r * n / k)
num_sheet += math.ceil(g * n / k)
num_sheet += math.ceil(b * n / k)
print(num_sheet)


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

def f(a, b, c):
	if a * b % c == 0:
		return int(a * b / c)
	else:
		return int(a * b / c) + 1
x = f(n[0], 2, n[1])
y = f(n[0], 5, n[1])
z = f(n[0], 8, n[1])
print(x + y + z)


(frnds, sheets) = map(int, input().split())
colors = [2 * frnds, 5 * frnds, 8 * frnds]
s = 0
if sheets >= 15 * frnds:
	s += 3
else:
	for i in colors:
		if i > sheets:
			if not i % sheets:
				s += i // sheets
			else:
				s += i // sheets + 1
		elif sheets % i:
			s += sheets // i
		else:
			s += 1
print(s)


import math
nk = input()
lst = [float(i) for i in nk.split()]
n = lst[0]
k = lst[1]
x = 2
y = 5
z = 8
m = math.ceil(x * n / k) + math.ceil(y * n / k) + math.ceil(z * n / k)
print(m)


import math as m
[n, k] = [int(x) for x in input().split()]
print(m.ceil(2 * n / k) + m.ceil(5 * n / k) + m.ceil(8 * n / k))


(n, m) = map(int, input().split())
(k, s) = (2 * n, 0)
if k % m == 0:
	s += int(k / m)
else:
	s += int(k / m) + 1
k = 5 * n
if k % m == 0:
	s += int(k / m)
else:
	s += int(k / m) + 1
k = 8 * n
if k % m == 0:
	s += int(k / m)
else:
	s += int(k / m) + 1
print(s)


a = list(map(int, input().split()))
n = a[0]
k = a[1]
r = 2 * n
g = 5 * n
b = 8 * n
rib = [r, g, b]
total = 0
for i in rib:
	p = i // k
	if i % k == 0:
		p = p
	else:
		p = p + 1
	total = total + p
print(total)


x = list(map(int, input().split(' ')))
print(abs(-x[0] * 2 // x[1]) + abs(-x[0] * 5 // x[1]) + abs(-x[0] * 8 // x[1]))


import math
entrada = list(map(int, input().split()))
amigos = entrada[0]
folhas = entrada[1]
compra_vermelha = math.ceil(amigos * 2 / folhas)
compra_verde = math.ceil(amigos * 5 / folhas)
compra_azul = math.ceil(amigos * 8 / folhas)
print(compra_azul + compra_verde + compra_vermelha)


import math
(n, k) = [int(i) for i in input().split()]
redCount = math.ceil(n * 2 / k)
greenCount = math.ceil(n * 5 / k)
blueCount = math.ceil(n * 8 / k)
print(redCount + blueCount + greenCount)


s = list(map(int, input().split(' ')))
n = s[0]
k = s[1]
red = n * 2
green = n * 5
blue = n * 8
t = red // k
if t * k != red:
	t = t + 1
a = t
t = green // k
if t * k != green:
	t = t + 1
a = a + t
t = blue // k
if t * k != blue:
	t = t + 1
a = a + t
print(a)


def one(t, n, k):
	if t * n / k > t * n // k:
		l = t * n // k + 1
	else:
		l = t * n // k
	return l
s = input().split()
n = int(s[0])
k = int(s[1])
print(int(one(2, n, k) + one(5, n, k) + one(8, n, k)))


(n, k) = map(int, input().split())
(a, b, c) = (2 * n, 5 * n, 8 * n)
ceil = lambda x, y: (x + y - 1) // y
print(ceil(a, k) + ceil(b, k) + ceil(c, k))


(n, k) = map(int, input().split())
no_blue = n * 8
no_red = n * 2
no_green = n * 5
x = no_blue // k
if no_blue % k != 0:
	x = x + 1
y = no_red // k
if no_red % k != 0:
	y += 1
z = no_green // k
if no_green % k != 0:
	z += 1
print(x + y + z)


from math import ceil
(a, b) = input().split()
a = int(a)
b = int(b)
k = ceil(2 / b * a)
z = ceil(5 / b * a)
s = ceil(8 / b * a)
print(k + z + s)


(friends, num_sheets) = map(int, input().split())
if friends * 2 % num_sheets != 0:
	red = friends * 2 // num_sheets + 1
else:
	red = friends * 2 // num_sheets
if friends * 5 % num_sheets != 0:
	green = friends * 5 // num_sheets + 1
else:
	green = friends * 5 // num_sheets
if friends * 8 % num_sheets != 0:
	blue = friends * 8 // num_sheets + 1
else:
	blue = friends * 8 // num_sheets
print(red + green + blue)


import math
(n, k) = [int(x) for x in input().split()]

def eval_(n_friends, per_friend, nlists):
	req = per_friend * n_friends
	return math.ceil(req / nlists)
result = eval_(n, 2, k) + eval_(n, 5, k) + eval_(n, 8, k)
print(result)


(x, y) = map(int, input().split())
t = int(x * 2 / y)
if x * 2 % y != 0:
	t = t + 1
t1 = int(x * 5 / y)
if x * 5 % y != 0:
	t1 = t1 + 1
t2 = int(x * 8 / y)
if x * 8 % y != 0:
	t2 = t2 + 1
print(t + t1 + t2)


import math
(guests, pages) = list(map(int, input().split()))
red = math.ceil(2 * guests / pages)
green = math.ceil(5 * guests / pages)
blue = math.ceil(8 * guests / pages)
print(red + green + blue)


(n, k) = map(int, input().split())
c = 2 * n // k
if 2 * n % k != 0:
	c += 1
x = max(0, 5 * n)
c += x // k
if x % k != 0:
	c += 1
x = max(0, 8 * n)
c += x // k
if x % k != 0:
	c += 1
print(c)


data = [int(i) for i in input().split()]
n = data.pop(0)
k = data.pop(0)
red = n * 2
green = n * 5
blue = n * 8
answer = 0
if red % k == 0:
	answer += red // k
else:
	answer += red // k + 1
if blue % k == 0:
	answer += blue // k
else:
	answer += blue // k + 1
if green % k == 0:
	answer += green // k
else:
	answer += green // k + 1
print(int(answer))


r = 2
g = 5
b = 8
arr = [int(x) for x in input().split()]
n = arr[0]
k = arr[1]
r = r * n
g = g * n
b = b * n
if r % k != 0:
	r = r // k + 1
else:
	r = r / k
if g % k != 0:
	g = g // k + 1
else:
	g = g / k
if b % k != 0:
	b = b // k + 1
else:
	b = b / k
print(int(r + g + b))


(n, k) = [int(n) for n in input().split()]
tot_green = 5 * n
tot_red = 2 * n
tot_blue = 8 * n
tot_green_bks = 5 * n // k
tot_red_bks = 2 * n // k
tot_blue_bks = 8 * n // k
if 5 * n % k != 0:
	tot_green_bks = tot_green_bks + 1
if 2 * n % k != 0:
	tot_red_bks = tot_red_bks + 1
if 8 * n % k != 0:
	tot_blue_bks = tot_blue_bks + 1
print(tot_green_bks + tot_red_bks + tot_blue_bks)


import math
(n, k) = [int(i) for i in input().split()]
red = n * 2
green = n * 5
blue = n * 8
redNotebooks = red / k
redNotebooks = math.ceil(redNotebooks)
greenNotebooks = green / k
greenNotebooks = math.ceil(greenNotebooks)
blueNotebooks = blue / k
blueNotebooks = math.ceil(blueNotebooks)
total = redNotebooks + greenNotebooks + blueNotebooks
print(total)


(n, k) = map(int, input().split())
if n * 2 % k != 0:
	a = n * 2 // k + 1
else:
	a = n * 2 // k
if n * 5 % k != 0:
	z = n * 5 // k + 1
else:
	z = n * 5 // k
if n * 8 % k != 0:
	b = n * 8 // k + 1
else:
	b = n * 8 // k
print(a + z + b)


(n, k) = map(int, input().split())
print(2 * n // k + 5 * n // k + 8 * n // k + (int(2 * n % k != 0) + int(5 * n % k != 0) + int(8 * n % k != 0)))


import math
[friendCount, k] = [int(x) for x in input().split(' ')]
redSheet = friendCount * 2
greenSheet = friendCount * 5
blueSheet = friendCount * 8
print(math.ceil(redSheet / k) + math.ceil(greenSheet / k) + math.ceil(blueSheet / k))


def Petya_origami():
	(n, k) = map(int, input().split(sep=' '))
	r = 2
	g = 5
	b = 8
	count_blocknot = (n * r - 1) // k + 1 + (n * g - 1) // k + 1 + (n * b - 1) // k + 1
	print(count_blocknot)
Petya_origami()


import math
(n, k) = [int(x) for x in input().split(' ')]
(r, g, b, cnt) = (2 * n, 5 * n, 8 * n, 0)
print(math.ceil(r / k) + math.ceil(g / k) + math.ceil(b / k))


import math
l = list(map(int, input().split(' ')))
(n, k) = l
l1 = []
l1.append(n * 2)
l1.append(n * 5)
l1.append(n * 8)
s = 0
for i in l1:
	t = math.ceil(i / k)
	s = s + t
print(s)


(n, k) = [int(x) for x in input().split()]
x = 0
x += n * 2 // k
if n * 2 % k != 0:
	x += 1
x += n * 5 // k
if n * 5 % k != 0:
	x += 1
x += n * 8 // k
if n * 8 % k != 0:
	x += 1
print(x)


(n, k) = list(map(int, input().split()))
r = 2 * n
g = 5 * n
b = 8 * n
R = r // k
G = g // k
B = b // k
if r % k == 0:
	RED = R
else:
	RED = R + 1
if g % k == 0:
	GREEN = G
else:
	GREEN = G + 1
if b % k == 0:
	BLUE = B
else:
	BLUE = B + 1
print(RED + GREEN + BLUE)


k = input().split()
n = []
for i in k:
	n.append(int(i))
res = 0
if n[0] * 2 % n[1] != 0:
	res += n[0] * 2 // n[1] + 1
if n[0] * 2 % n[1] == 0:
	res += n[0] * 2 // n[1]
if n[0] * 8 % n[1] != 0:
	res += n[0] * 8 // n[1] + 1
if n[0] * 8 % n[1] == 0:
	res += n[0] * 8 // n[1]
if n[0] * 5 % n[1] != 0:
	res += n[0] * 5 // n[1] + 1
if n[0] * 5 % n[1] == 0:
	res += n[0] * 5 // n[1]
print(res)


(x, y) = map(int, input().split())
a = 2 * x
b = 5 * x
c = 8 * x
count = 0
if a % y != 0:
	count = count + a // y + 1
else:
	count = count + a // y
if b % y != 0:
	count = count + b // y + 1
else:
	count = count + b // y
if c % y != 0:
	count = count + c // y + 1
else:
	count = count + c // y
print(count)


from fractions import gcd
import math
from itertools import permutations
from itertools import combinations
import calendar
from itertools import product

def readInts():
	return list(map(int, raw_input().strip().split()))

def readInt():
	return int(raw_input())

def readStrs():
	return raw_input().split()

def readStr():
	return raw_input()

def readarr(n):
	return [map(int, list(readStr())) for i in xrange(n)]

def readnumbertolist():
	a = [int(i) for i in list(raw_input())]
	return a

def strlistTostr(list1):
	return ''.join(list1)

def numlistTostr(list1):
	return ''.join((str(e) for e in list1))

def strTolist(str):
	return str.split()

def strlistTointlist(str):
	return map(int, str)

def slicenum(number, x):
	return int(str(number)[:x])

def precise(num):
	return '{0:.10f}'.format(num)

def rsorted(a):
	return sorted(a, reverse=True)

def binar(x):
	return '{0:031b}'.format(x)

def findpermute(word):
	perms = [''.join(p) for p in permutations(word)]
	return set(perms)

def findsubsets(S, m):
	return set(itertools.combinations(S, m))

def sort1(yy, index):
	return yy.sort(key=lambda x: x[index])

def reversepair(yy):
	return yy[::-1]

def checkint(x):
	return x.is_integer()

def sum_digits(n):
	s = 0
	while n:
		s += n % 10
		n //= 10
	return s

def vowel_count(str):
	count = 0
	vowel = set('aeiouAEIOU')
	for alphabet in str:
		if alphabet in vowel:
			count = count + 1
	return count

def leapyear(year):
	return calendar.isleap(year)

def primes_sieve(limit):
	limitn = limit + 1
	not_prime = set()
	primes = []
	for i in range(2, limitn):
		if i in not_prime:
			continue
		for f in range(i * 2, limitn, i):
			not_prime.add(f)
		primes.append(i)
	return primes

def distinctstr(s):
	t = ''.join(set(s))
	return t

def countdict(s):
	d = {}
	for i in range(len(s)):
		if s[i] not in d.keys():
			d[s[i]] = 1
		else:
			d[s[i]] += 1
	return d
import operator as op

def nck(n, k):
	k = min(n - k, k)
	result = 1
	for i in range(1, k + 1):
		result = result * (n - i + 1) / i
	return result

def matrixcheck(x, y):
	faadu = []
	directions = zip((0, 0, 1, -1), (1, -1, 0, 0))
	for (dx, dy) in directions:
		if R > x + dx >= 0 <= y + dy < C and A[x + dx][y + dy] == 0:
			faadu.append((x + dx, y + dy))
	return faadu

def stringcount(s):
	return [s.count(i) for i in 'abcdefghijklmnopqrstuvwxyz']

def bubbleSort(arr):
	n = len(arr)
	for i in range(n):
		for j in range(0, n - i - 1):
			if arr[j] > arr[j + 1]:
				(arr[j], arr[j + 1]) = (arr[j + 1], arr[j])

def isSubsetSum(st, n, sm):
	subset = [[True] * (sm + 1)] * (n + 1)
	for i in range(0, n + 1):
		subset[i][0] = True
	for i in range(1, sm + 1):
		subset[0][i] = False
	for i in range(1, n + 1):
		for j in range(1, sm + 1):
			if j < st[i - 1]:
				subset[i][j] = subset[i - 1][j]
			if j >= st[i - 1]:
				subset[i][j] = subset[i - 1][j] or subset[i - 1][j - st[i - 1]]
	return subset[n][sm]

def decimal_to_octal(dec):
	decimal = int(dec)
	return oct(decimal)

def decimal_to_binary(dec):
	decimal = int(dec)
	return bin(decimal)

def decimal_to_hexadecimal(dec):
	decimal = int(dec)
	return hex(decimal)

def solve():
	(n, k) = map(int, input().strip().split())
	(red, green, blue) = (2 * n, 5 * n, 8 * n)
	cnt = 0
	if red % k == 0:
		cnt += red // k
	else:
		cnt += red // k + 1
	if green % k == 0:
		cnt += green // k
	else:
		cnt += green // k + 1
	if blue % k == 0:
		cnt += blue // k
	else:
		cnt += blue // k + 1
	print(cnt)
solve()


(n, k) = input().split()
k = int(k)
n = int(n)
r = 2 * n
b = 5 * n
g = 8 * n
sum = 0
if r % k != 0:
	sum += int(r / k) + 1
else:
	sum += int(r / k)
if g % k != 0:
	sum += int(g / k) + 1
else:
	sum += int(g / k)
if b % k != 0:
	sum += int(b / k) + 1
else:
	sum += int(b / k)
print(sum)


import math
(n, m) = map(int, input().split())
r = 2 * n
g = n * 5
b = n * 8
count = 0
count += math.ceil(r / m)
count += math.ceil(g / m)
count += math.ceil(b / m)
print(count)


from math import ceil

def main():
	(n, k) = [int(v) for v in input().split()]
	b = 2 * n
	g = 5 * n
	bl = 8 * n
	print(ceil(b / k) + ceil(g / k) + ceil(bl / k))
main()


import math
import array
arr = [int(n) for n in input().split()]
k = math.ceil(2 * arr[0] / arr[1]) + math.ceil(5 * arr[0] / arr[1]) + math.ceil(8 * arr[0] / arr[1])
print(k)


def mainA():
	(n, k) = list(map(int, input().split()))
	print((n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k)
mainA()


from math import ceil
numero = input().split()
n = float(numero[0])
k = inv = float(numero[1])
red = ceil(2.0 * n / k)
green = ceil(5.0 * n / k)
blue = ceil(8.0 * n / k)
print(red + green + blue)


from math import ceil
[n, k] = list(map(float, input().split()))
print(ceil(2 * n / k) + ceil(5 * n / k) + ceil(8 * n / k))


(n, k) = input().split(' ')
n_int = int(n)
k_int = int(k)
total_red = n_int * 2
total_green = n_int * 5
total_blue = n_int * 8
red_notes = total_red // k_int
blue_notes = total_blue // k_int
green_notes = total_green // k_int
red_notes = red_notes if total_red % k_int == 0 else red_notes + 1
blue_notes = blue_notes if total_blue % k_int == 0 else blue_notes + 1
green_notes = green_notes if total_green % k_int == 0 else green_notes + 1
print(red_notes + blue_notes + green_notes)


(n, k) = map(int, input().split())
red = n * 2 // k
if n * 2 % k != 0:
	red += 1
green = n * 5 // k
if n * 5 % k != 0:
	green += 1
blue = n * 8 // k
if n * 8 % k != 0:
	blue += 1
total = red + green + blue
print(f'{total}')


a = list(map(int, input().split()))
b = a[0]
c = a[1]
d = 2 * b // c
if 2 * b % c > 0:
	d += 1
e = 5 * b // c
if 5 * b % c > 0:
	e += 1
f = 8 * b // c
if 8 * b % c > 0:
	f += 1
z = d + e + f
print(z)


import math
(n, k) = [int(i) for i in input().split()]
quantity = [2, 5, 8]
a = 0
for i in quantity:
	a += math.ceil(n * int(i) / k)
print(a)


r = 2
g = 5
b = 8
(n, k) = list(map(int, input().split()))
a = r * n
l = g * n
m = b * n
if a % k == 0:
	s = int(a / k)
else:
	s = a // k + 1
if l % k == 0:
	r = int(l / k)
else:
	r = l // k + 1
if m % k == 0:
	t = int(m / k)
else:
	t = m // k + 1
print(s + r + t)


import math
(n, k) = input().split()
(n, k) = [int(n), int(k)]
m1 = n * 2
m2 = n * 5
m3 = n * 8
ans1 = math.ceil(m1 / k)
ans2 = math.ceil(m2 / k)
ans3 = math.ceil(m3 / k)
print(ans1 + ans2 + ans3)


from operator import itemgetter
(n, k) = map(int, input().split())
ans = 0
ans += n * 2 // k + (n * 2 % k != 0)
ans += n * 5 // k + (n * 5 % k != 0)
ans += n * 8 // k + (n * 8 % k != 0)
print(ans)


(n, k) = map(int, input().split())
if n * 8 % k == 0:
	b = 8 * n // k
else:
	b = 8 * n // k + 1
if 5 * n % k == 0:
	v = 5 * n // k
else:
	v = 5 * n // k + 1
if 2 * n % k == 0:
	r = 2 * n // k
else:
	r = 2 * n // k + 1
print(r + v + b)


(n, p) = map(int, input().split())
if n * 2 % p == 0:
	r = n * 2 / p
else:
	r = n * 2 // p + 1
if n * 5 % p == 0:
	g = n * 5 / p
else:
	g = n * 5 // p + 1
if n * 8 % p == 0:
	b = n * 8 / p
else:
	b = n * 8 // p + 1
print(int(r + g + b))


import logging, sys
logging.basicConfig(level=logging.INFO)

def main():
	(n, k) = map(int, sys.stdin.readline().split())
	re = 2 * n
	gr = 5 * n
	bl = 8 * n
	ans = re // k + (re % k != 0) + gr // k + (gr % k != 0) + bl // k + (bl % k != 0)
	print(ans)
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
main()


import math
(a, b) = [int(x) for x in input().split()]
print(math.ceil(a * 2 / b) + math.ceil(a * 5 / b) + math.ceil(a * 8 / b))


[n, k] = [int(i) for i in input().split()]
red = (2 * n - 1) // k + 1
gre = (5 * n - 1) // k + 1
blu = (8 * n - 1) // k + 1
print(red + gre + blu)


def ost(a, b):
	return a % b != 0
(n, k) = list(map(int, input().split()))
ans = n * 2 // k + ost(n * 2, k)
ans += n * 5 // k + ost(n * 5, k)
ans += n * 8 // k + ost(n * 8, k)
print(ans)


(nFriends, listsInNotebook) = map(int, input().split())
minimalLists = [nFriends * 2, nFriends * 5, nFriends * 8]
nBuyingNotebooks = 0
for i in range(3):
	if minimalLists[i] % listsInNotebook == 0:
		nBuyingNotebooks += minimalLists[i] // listsInNotebook
	else:
		nBuyingNotebooks += minimalLists[i] // listsInNotebook + 1
print(nBuyingNotebooks)


(n, k) = [int(x) for x in input().split()]
x = n * 2
y = n * 5
z = n * 8
s = x // k + y // k + z // k
if x % k != 0:
	s += 1
if y % k != 0:
	s += 1
if z % k != 0:
	s += 1
print(s)


(n, k) = map(int, input().split())
rc = n * 2
gc = n * 5
bc = n * 8
if rc % k != 0:
	rc = rc // k + 1
else:
	rc = rc // k
if gc % k != 0:
	gc = gc // k + 1
else:
	gc = gc // k
if bc % k != 0:
	bc = bc // k + 1
else:
	bc = bc // k
print(rc + gc + bc)


import math
(n, s) = map(int, input().split())
r = math.ceil(2 * n / s)
g = math.ceil(5 * n / s)
b = math.ceil(8 * n / s)
print(r + g + b)


from math import ceil as m
(friend, page) = map(int, input().split())
rd_pg = friend * 2
gr_pg = friend * 5
bl_pg = friend * 8
no_of_book = m(rd_pg / page) + m(bl_pg / page) + m(gr_pg / page)
print(no_of_book)


import math
(n, k) = list(map(int, input().split()))
result = 0
result += math.ceil(n * 2 / k)
result += math.ceil(n * 5 / k)
result += math.ceil(n * 8 / k)
print(result)


a = [2, 5, 8]

def origami(n, k):
	b = [i * n for i in a]
	c = list()
	for elem in b:
		if elem % k == 0:
			c.append(elem // k)
		if elem % k != 0:
			c.append(elem // k + 1)
	return sum(c)
(N, K) = [int(j) for j in input().split()]
print(origami(N, K))


def solve(g):
	l = [g[0] * 2, g[0] * 5, g[0] * 8]
	total = 0
	for i in l:
		if i % g[1] == 0:
			total += i // g[1]
		else:
			total += i // g[1] + 1
	print(total)

def main():
	solve([int(x) for x in input().split()])
main()


from math import ceil
(n, k) = map(int, input().split())
lst = [ceil(i * n / k) for i in [2, 5, 8]]
print(sum(lst))


(n, k) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
l = [r, g, b]
s = 0
for i in l:
	if i % k == 0:
		s += i // k
	else:
		s += i // k + 1
print(s)


(n, k) = input().split()
r = int(n) * 2
g = int(n) * 5
b = int(n) * 8
if r % int(k) == 0:
	x = r / int(k)
else:
	x1 = r // int(k)
	x = x1 + 1
if g % int(k) == 0:
	y = g / int(k)
else:
	y1 = g // int(k)
	y = y1 + 1
if b % int(k) == 0:
	z = b / int(k)
else:
	z1 = b // int(k)
	z = z1 + 1
sum = x + y + z
print(int(sum))


(n, k) = [int(v) for v in input().split()]
need = {'red': 2 * n, 'blue': 8 * n, 'green': 5 * n}
need_notes = {}
for (color, count) in need.items():
	notes = divmod(count, k)
	need_notes[color] = 1 if notes[1] else 0
	need_notes[color] += notes[0]
print(sum(need_notes.values()))


(n, k) = input().split()
(n, k) = (int(n), int(k))
(r, g, b) = (n * 2 / k, n * 5 / k, n * 8 / k)
s = int(r) + int(g) + int(b)
if r > int(r):
	s += 1
if g > int(g):
	s += 1
if b > int(b):
	s += 1
print(s)


string = input().split(' ')
n = int(string[0])
k = int(string[1])
red = -(-(n * 8) // k)
green = -(-(n * 5) // k)
blue = -(-(n * 2) // k)
print(str(red + green + blue))


(friends, sheets) = input().split()
friends = int(friends)
sheets = int(sheets)
red = friends * 2 % sheets
green = friends * 5 % sheets
blue = friends * 8 % sheets
if red != 0:
	sheets_red = friends * 2 // sheets + 1
else:
	sheets_red = friends * 2 // sheets
if green != 0:
	sheets_green = friends * 5 // sheets + 1
else:
	sheets_green = friends * 5 // sheets
if blue != 0:
	sheets_blue = friends * 8 // sheets + 1
else:
	sheets_blue = friends * 8 // sheets
print(sheets_red + sheets_green + sheets_blue)


import math
(n, k) = map(int, input().split())
r = 2
g = 5
b = 8
rs = math.ceil(n * r / k)
gs = math.ceil(n * g / k)
bs = math.ceil(n * b / k)
print(rs + gs + bs)


(n, m) = [int(x) for x in input().split()]
(r, g, b) = (n * 2 // m, n * 5 // m, n * 8 // m)
if n * 2 % m != 0:
	r += 1
if n * 5 % m != 0:
	g += 1
if n * 8 % m != 0:
	b += 1
print(r + g + b)


s = input()
s = s.split()
for j in range(len(s)):
	s[j] = int(s[j])
n = s[0]
k = s[1]
red = 2 * n
green = 5 * n
blue = 8 * n
res = 0
if red % k == 0:
	res = res + red // k
else:
	res = res + red // k + 1
if green % k == 0:
	res = res + green // k
else:
	res = res + green // k + 1
if blue % k == 0:
	res = res + blue // k
else:
	res = res + blue // k + 1
print(res)


(n, k) = map(int, input().split())
ans_1 = n * 2 // k + int(n * 2 % k != 0)
ans_2 = n * 5 // k + int(n * 5 % k != 0)
ans_3 = n * 8 // k + int(n * 8 % k != 0)
print(ans_1 + ans_2 + ans_3)


notebooks = 0
(friends, sheets) = [int(j) for j in input().split()]
redS = 2 * friends
greenS = 5 * friends
blueS = 8 * friends
colors = [redS, greenS, blueS]
for i in range(len(colors)):
	if 0 < colors[i] % sheets < sheets:
		notebooks += int(colors[i] / sheets) + 1
	else:
		notebooks += int(colors[i] / sheets)
print(notebooks)


def main():
	(n, k) = map(int, input().split())
	v = cal(2, n, k) + cal(5, n, k) + cal(8, n, k)
	print(v)

def cal(m, n, k):
	return m * n // k + int(m * n % k != 0)
main()


from math import ceil
inp = input()
inp = inp.split()
n = int(inp[0])
k = int(inp[1])
r = 2
g = 5
b = 8
quantidade = ceil(n * r / k) + ceil(n * g / k) + ceil(n * b / k)
print(quantidade)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
r = (2 * n % k == 0) * (2 * n / k) + (2 * n % k is not 0) * (int(2 * n / k) + 1)
b = (5 * n % k == 0) * (5 * n / k) + (5 * n % k is not 0) * (int(5 * n / k) + 1)
g = (8 * n % k == 0) * (8 * n / k) + (8 * n % k is not 0) * (int(8 * n / k) + 1)
print(int(r + b + g))


from math import ceil
args = [int(x) for x in input().split(' ')]
n = args[0]
k = args[1]
reds = 2 * n
greens = 5 * n
blues = 8 * n
print(str(ceil(reds / k) + ceil(greens / k) + ceil(blues / k)))


import sys
counter = 0
(number_friends, count_sheets) = map(int, sys.stdin.readline().split())
for color in range(2, 9, 3):
	result = number_friends * color
	if result % count_sheets == 0:
		counter += result // count_sheets
	else:
		counter += result // count_sheets + 1
print(counter)


import math
(n, k) = map(int, input().split())
x = math.ceil(8 * n / k)
y = math.ceil(5 * n / k)
z = math.ceil(2 * n / k)
print(x + y + z)


import math
color = [2, 5, 8]
(a, b) = map(int, input().split())
color = [i * a / b for i in color]
print(math.ceil(color[0]) + math.ceil(color[1]) + math.ceil(color[2]))


class PandO:
	(n, k) = map(int, input().split())
	red = (2 * n + k - 1) // k
	green = (5 * n + k - 1) // k
	blue = (8 * n + k - 1) // k
	print(red + green + blue)


R = lambda : map(int, input().split())

def cl(n, a):
	return [n // a, n // a + 1][n % a != 0]
(n, k) = R()
print(cl(n * 2, k) + cl(n * 5, k) + cl(n * 8, k))


(n, k) = map(int, input().split())
(red, green, blue) = (2 * n, 5 * n, 8 * n)
print(sum((e // k + (0 if e % k == 0 else 1) for e in [red, green, blue])))


from math import ceil
(n, k) = map(int, input().split())
a = 2 * n
b = 5 * n
c = 8 * n
print(ceil(a / k) + ceil(b / k) + ceil(c / k))


import math
first = list(map(int, input().split()))
print(math.ceil(first[0] * 2 / first[1]) + math.ceil(first[0] * 5 / first[1]) + math.ceil(first[0] * 8 / first[1]))


import math
(a, b) = map(int, input().split())
red = 2
green = 5
blue = 8
chndta_grmz = math.ceil(a * red / b)
chndta_sabz = math.ceil(a * green / b)
chndta_abi = math.ceil(a * blue / b)
print(chndta_sabz + chndta_abi + chndta_grmz)


import math
(n, k) = map(int, input().split())
red_n = math.ceil(2 * n / k)
green_n = math.ceil(5 * n / k)
blue_n = math.ceil(8 * n / k)
total = red_n + green_n + blue_n
print(total)


(a, b) = map(int, input().split())
s = a * 2 // b + a * 5 // b + a * 8 // b
if a * 2 % b != 0:
	s = s + 1
if a * 5 % b != 0:
	s = s + 1
if a * 8 % b != 0:
	s = s + 1
print(int(s))


(n, m) = map(int, input().split())
a = 2 * n
b = 5 * n
c = 8 * n
d = a // m + b // m + c // m
if a % m != 0:
	d += 1
if b % m != 0:
	d += 1
if c % m != 0:
	d += 1
print(d)


from math import ceil
(n, k) = map(int, input().split(' '))
count = 0
for m in [2, 5, 8]:
	count += ceil(m * n / k)
print(count)


input = list(input().split(' '))
n = int(input[0])
k = int(input[-1])
origami = [2, 5, 8]
n_notebooks = []
total = 0
for color in origami:
	total += -(-color * n // k)
print(total)


import math
(r, g, b) = (2, 5, 8)
(n, k) = map(int, input().split())
r *= n
g *= n
b *= n
print(str(sum([math.ceil(r / k), math.ceil(g / k), math.ceil(b / k)])), end='')


(n, k) = map(int, input().split())
i = 2 * n
j = 5 * n
m = 8 * n
a = 0
if i % k == 0:
	a = a + i // k
else:
	a = a + i // k + 1
if j % k == 0:
	a = a + j // k
else:
	a = a + j // k + 1
if m % k == 0:
	a = a + m // k
else:
	a = a + m // k + 1
print(a)


(n, k) = (int(v) for v in input().split())
if 2 * n % k == 0:
	a = 2 * n // k
else:
	a = 2 * n // k + 1
if 5 * n % k == 0:
	b = 5 * n // k
else:
	b = 5 * n // k + 1
if 8 * n % k == 0:
	c = 8 * n // k
else:
	c = 8 * n // k + 1
print(a + b + c)


import math
l = input().split()
a = int(l[0])
b = int(l[1])
print(math.ceil(2 * a / b) + math.ceil(5 * a / b) + math.ceil(8 * a / b))


def solve():
	(n, k) = map(int, input().split())
	print((2 * n + k - 1) // k + (5 * n + k - 1) // k + (8 * n + k - 1) // k)

def main():
	t = 1
	for _ in range(t):
		solve()
main()


import math
(f, numSheet) = map(int, input().split())
r = 2
g = 5
b = 8
numR = math.ceil(r * f / numSheet)
numG = math.ceil(g * f / numSheet)
numB = math.ceil(b * f / numSheet)
print(numR + numG + numB)


import math
(n, k) = map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
r1 = int(math.ceil(r / k))
g1 = int(math.ceil(g / k))
b1 = int(math.ceil(b / k))
print(r1 + g1 + b1)


(n, k) = [int(i) for i in input().split()]
n = int(n)
k = int(k)
r = 2 * n
g = 5 * n
b = 8 * n
cr = r // k
cg = g // k
cb = b // k
if r % k != 0:
	cr += 1
if g % k != 0:
	cg += 1
if b % k != 0:
	cb += 1
print(cr + cg + cb)


import math
(c, d) = list(map(int, input().split()))
print(math.ceil(c * 2 / d) + math.ceil(c * 5 / d) + math.ceil(c * 8 / d))


import math

def Origami():
	(n, k) = map(int, input().split())
	books = 0
	books += math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k)
	print(books)
Origami()


import math
import collections
import bisect
import heapq
import time
import itertools
import sys
(N, K) = map(int, input().split())
r = 2 * N // K
g = 5 * N // K
b = 8 * N // K
if r * K < 2 * N:
	r += 1
if g * K < 5 * N:
	g += 1
if b * K < 8 * N:
	b += 1
print(r + g + b)


import sys
import random
from itertools import permutations, combinations
from math import sqrt, fabs, ceil
from collections import namedtuple
in_file_path = 'input.txt'
output_file_path = 'output.txt'
SUBMIT = True

def read_num(fin, num_type=int):
	tmp_list = [num_type(x) for x in fin.readline().strip().split()]
	num_count = len(tmp_list)
	if num_count == 1:
		return tmp_list[0]
	elif num_count == 2:
		return (tmp_list[0], tmp_list[1])
	elif num_count == 3:
		return (tmp_list[0], tmp_list[1], tmp_list[2])
	elif num_count == 4:
		return (tmp_list[0], tmp_list[1], tmp_list[2], tmp_list[3])
	print("Can't solve :", tmp_list)
	assert False

def solve(fin, fout):
	(n, k) = read_num(fin)
	print(ceil(n * 8.0 / k) + ceil(n * 2.0 / k) + ceil(n * 5.0 / k))

def solve_it():
	global in_file_path, output_file_path, SUBMIT
	if not SUBMIT:
		fin = open(in_file_path, 'r')
		fout = open(output_file_path, 'w')
	else:
		fin = sys.stdin
		fout = sys.stdout
	solve(fin, fout)
	fin.close()
	fout.close()
solve_it()


import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

def getIntList():
	return list(map(int, input().split()))
try:
	import numpy

	def dprint(*args, **kwargs):
		print(*args, file=sys.stderr)
	dprint('debug mode')
except Exception:

	def dprint(*args, **kwargs):
		pass
inId = 0
outId = 0
if inId > 0:
	dprint('use input', inId)
	sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
	dprint('use output', outId)
	sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
	atexit.register(lambda : sys.stdout.close())
(N, K) = getIntList()

def getD(g):
	return (g - 1) // K + 1
print(getD(2 * N) + getD(5 * N) + getD(8 * N))


def gerd(x, n):
	if x % n == 0:
		return x // n
	else:
		return x // n + 1
n1 = input().split()
n = int(n1[0])
k = int(n1[1])
s1 = gerd(n * 2, k)
s2 = gerd(n * 5, k)
s3 = gerd(n * 8, k)
s = s1 + s2 + s3
print(s)


(n, k) = map(int, input().split())
a = n * 2
b = n * 5
c = n * 8
s = a // k + b // k + c // k
if a % k != 0:
	s += 1
if b % k != 0:
	s += 1
if c % k != 0:
	s += 1
print(s)


import math
(n, k) = [int(i) for i in input().split()]
red_sheets = 2
green_sheets = 5
blue_sheets = 8
red_needed = red_sheets * n
green_needed = green_sheets * n
blue_needed = blue_sheets * n
sum = math.ceil(red_needed / k) + math.ceil(blue_needed / k) + math.ceil(green_needed / k)
print(sum)


import math
o = input().rstrip().split(' ')
N = int(o[0])
A = 2 * N
B = 5 * N
C = 8 * N
ans = 0
k = int(o[1])
if A < k:
	ans += 1
else:
	D = int(math.ceil(A / k))
	ans += D
A = B
if A < k:
	ans += 1
else:
	D = int(math.ceil(A / k))
	ans += D
A = C
if A < k:
	ans += 1
else:
	D = int(math.ceil(A / k))
	ans += D
print(ans)


arr = list(map(int, input().split()))
(n, k) = (arr[0], arr[1])
sum = 0
(r, g, b) = (n * 2, n * 5, n * 8)
(r0, g0, b0) = (r % k, g % k, b % k)
(r1, g1, b1) = (r / k, g / k, b / k)
if r0 == 0:
	sum = sum + r1
else:
	sum = sum + int(r1) + 1
if g0 == 0:
	sum = sum + g1
else:
	sum = sum + int(g1) + 1
if b0 == 0:
	sum = sum + b1
else:
	sum = sum + int(b1) + 1
print(int(sum))


from math import ceil
(n, k) = map(int, input().split())
red = n * 2
gre = 5 * n
blu = 8 * n
res = ceil(red / k) + ceil(gre / k) + ceil(blu / k)
print(res)


entrada = input().split()
n = int(entrada[0])
k = int(entrada[1])
suma = 0
RED_NEED = 2
GREEN_NEED = 5
BLUE_NEED = 8
red_notebooks = int(RED_NEED * n / k) + 1
if RED_NEED * n % k == 0:
	red_notebooks -= 1
green_notebooks = int(GREEN_NEED * n / k) + 1
if GREEN_NEED * n % k == 0:
	green_notebooks -= 1
blue_notebooks = int(BLUE_NEED * n / k) + 1
if BLUE_NEED * n % k == 0:
	blue_notebooks -= 1
ans = red_notebooks + green_notebooks + blue_notebooks
print(ans)


(n, k) = map(int, input().split())
a = [n * ai for ai in [2, 5, 8]]

def ceil(a, b):
	return -(-a // b)
ans = 0
for ai in a:
	ans += ceil(ai, k)
print(ans)


(n, k) = map(int, input().split())

def round(x):
	if int(x) == x:
		return x
	return int(x) + 1
r = round(2 * n / k)
g = round(5 * n / k)
b = round(8 * n / k)
print(int(r + g + b))


nums = list(map(int, input().split(' ')))
n = nums[0]
k = nums[1]
reds = n * 2 // k
reds += 1 if n * 2 % k else 0
greens = n * 5 // k
greens += 1 if n * 5 % k else 0
blues = n * 8 // k
blues += 1 if n * 8 % k else 0
print(reds + blues + greens)


import math
number = map(int, input().split())
(n, k) = number
k1 = math.ceil(n * 2 / k)
k2 = math.ceil(n * 5 / k)
k3 = math.ceil(n * 8 / k)
print(k1 + k2 + k3)


(n, k) = [int(i) for i in input().split()]
r = 2 * n
g = 5 * n
b = 8 * n
c = 0
c += r // k + g // k + b // k
if r % k != 0:
	c += 1
if g % k != 0:
	c += 1
if b % k != 0:
	c += 1
print(c)


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
from fractions import Fraction

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

def si():
	return str(input())

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

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

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

def fsi():
	return str(stdin.readline())

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

def fli():
	return list(fmi())
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 = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

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

def ntl(n):
	return [int(i) for i in str(n)]

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

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)
(n, k) = mi()
a = n * 2
b = n * 5
c = n * 8
print(int(ceil(a / k) + ceil(b / k) + ceil(c / k)))


(n, k) = map(int, input().split())
p1 = n * 2 // k
if n * 2 % k != 0:
	p1 += 1
p2 = n * 5 // k
if n * 5 % k != 0:
	p2 += 1
p3 = n * 8 // k
if n * 8 % k != 0:
	p3 += 1
print(p1 + p2 + p3)


x = list(map(int, input().split()))
a = x[0]
b = x[1]
r = 2 * a
g = 5 * a
bl = 8 * a
if r % b != 0:
	R = r // b + 1
elif r % b == 0:
	R = r // b
if g % b != 0:
	G = g // b + 1
elif g % b == 0:
	G = g // b
if bl % b != 0:
	B = bl // b + 1
elif bl % b == 0:
	B = bl // b
print(R + B + G)


import sys
import math
r = lambda : sys.stdin.readline()
(n, m) = map(int, r().split())
red = math.ceil(n * 2 / m)
green = math.ceil(n * 5 / m)
blue = math.ceil(n * 8 / m)
answer = int(red + green + blue)
print(answer)


def inint():
	return int(input())

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

def main():
	(n, k) = inlist()
	from math import ceil as cl
	ch = cl(2 * n / k) + cl(5 * n / k) + cl(8 * n / k)
	print(ch)
main()


(n, k) = list(map(int, input().split()))
red = 2 * n
green = 5 * n
blue = 8 * n
R = red // k
G = green // k
B = blue // k
if red % k == 0:
	RED = R
else:
	RED = R + 1
if green % k == 0:
	GREEN = G
else:
	GREEN = G + 1
if blue % k == 0:
	BLUE = B
else:
	BLUE = B + 1
print(RED + GREEN + BLUE)


nk = list(map(int, input().split()))
red = nk[0] * 2
green = nk[0] * 5
blue = nk[0] * 8
summ = 0
if red % nk[1] == 0:
	summ += red // nk[1]
else:
	summ += red // nk[1] + 1
if green % nk[1] == 0:
	summ += green // nk[1]
else:
	summ += green // nk[1] + 1
if blue % nk[1] == 0:
	summ += blue // nk[1]
else:
	summ += blue // nk[1] + 1
print(summ)


nk = [int(x) for x in input().split()]
n = nk[0]
k = nk[1]
final = []
r = 2 * n
g = 5 * n
b = 8 * n
rgb = [r, g, b]
for i in rgb:
	if i % k != 0:
		final.append(i // k + 1)
	else:
		final.append(i // k)
print(sum(final))


z = list(map(int, input().split()))
red = z[0] * 2
green = z[0] * 5
blue = z[0] * 8
count = 0
import math
count += math.ceil(red / z[1])
count += math.ceil(green / z[1])
count += math.ceil(blue / z[1])
print(count)


a = input().split()
n = int(a[0])
k = int(a[1])
print((n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k)


from math import ceil
t = 1
for test in range(t):
	(n, k) = list(map(int, input().split()))
	ceil(n * 8 / k)
	print(ceil(n * 8 / k) + ceil(n * 5 / k) + ceil(n * 2 / k))


import math
(friend, page) = list(map(int, input().split()))
print(math.ceil(friend * 2 / page) + math.ceil(friend * 5 / page) + math.ceil(friend * 8 / page))


(n, k) = list(map(int, input().split()))
red = 2 * n
green = 5 * n
blue = 8 * n
count = 0
if red <= k:
	count += 1
if green <= k:
	count += 1
if blue <= k:
	count += 1
if red > k and red % k == 0:
	count += red // k
if red > k and red % k != 0:
	count += red // k + 1
if blue > k and blue % k == 0:
	count += blue // k
if blue > k and blue % k != 0:
	count += blue // k + 1
if green > k and green % k == 0:
	count += green // k
if green > k and green % k != 0:
	count += green // k + 1
print(count)


from sys import stdin, stdout
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
(n, k) = map(int, stdin.readline().split())
stdout.write(str((n * 2 + k - 1) // k + (n * 5 + k - 1) // k + (n * 8 + k - 1) // k))


(n, k) = list(map(int, input().split()))
ans = 0
vals = [2, 5, 8]
for v in vals:
	ans += (v * n + k - 1) // k
print(ans)


import sys
import math

def main():
	(n, k) = [int(i) for i in input().split()]
	red = math.ceil(n * 2 / k)
	green = math.ceil(n * 5 / k)
	blue = math.ceil(n * 8 / k)
	print('{}'.format(int(red + green + blue)))
main()


(n, k) = map(int, input().split())
l = 2 * n
m = 5 * n
n = 8 * n
r = l // k
g = m // k
b = n // k
if l % k != 0:
	r += 1
if m % k != 0:
	g += 1
if n % k != 0:
	b += 1
print(r + g + b)


def notebook(friend, sheetsInEachNotebook):
	(rR, rG, rB) = (2 * friend, 5 * friend, 8 * friend)
	if rR % sheetsInEachNotebook == 0:
		red = int(rR / sheetsInEachNotebook)
	else:
		red = int(rR / sheetsInEachNotebook) + 1
	if rG % sheetsInEachNotebook == 0:
		green = int(rG / sheetsInEachNotebook)
	else:
		green = int(rG / sheetsInEachNotebook) + 1
	if rB % sheetsInEachNotebook == 0:
		blue = int(rB / sheetsInEachNotebook)
	else:
		blue = int(rB / sheetsInEachNotebook) + 1
	return red + green + blue
entry = list(map(int, input().split()))
print(notebook(entry[0], entry[1]))


(n, k) = map(int, input().split())
er = 2 * n
eg = 5 * n
eb = 8 * n
s = 0
if er % k == 0:
	s += er // k
else:
	s += er // k + 1
if eg % k == 0:
	s += eg // k
else:
	s += eg // k + 1
if eb % k == 0:
	s += eb // k
else:
	s += eb // k + 1
print(s)


__author__ = 'tanunia'
from sys import stdin
(n, k) = [int(x) for x in stdin.readline().split()]
res = 0
for c in [2, 5, 8]:
	res += int(c * n / k)
	if c * n % k > 0:
		res += 1
print(res)


(n, m) = map(int, input().split())
r = n * 2
g = n * 5
b = n * 8
ans = r // m + bool(r % m) + g // m + bool(g % m) + b // m + bool(b % m)
print(ans)


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):
	return ' '.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)
(n, m) = isp()
n2 = n * 2
n5 = n * 5
n8 = n * 8
p = 0
p = ceil(n2 / m) + ceil(n5 / m) + ceil(n8 / m)
print(p)


import math
entry = input()
(friends, pack) = entry.split()
number_of_friends = int(friends)
sheets_per_pack = int(pack)
need_red = 2 * number_of_friends
need_green = 5 * number_of_friends
need_blue = 8 * number_of_friends
number_of_books = math.ceil(need_red / sheets_per_pack) + math.ceil(need_green / sheets_per_pack) + math.ceil(need_blue / sheets_per_pack)
print(number_of_books)


(friends_count, no_sheets_book) = input().split(' ')
(friends_count, no_sheets_book) = (int(friends_count), int(no_sheets_book))
if friends_count * 2 % no_sheets_book != 0:
	red_book = friends_count * 2 // no_sheets_book + 1
else:
	red_book = friends_count * 2 / no_sheets_book
if friends_count * 5 % no_sheets_book != 0:
	green_book = friends_count * 5 // no_sheets_book + 1
else:
	green_book = friends_count * 5 / no_sheets_book
if friends_count * 8 % no_sheets_book != 0:
	blue_book = friends_count * 8 // no_sheets_book + 1
else:
	blue_book = friends_count * 8 / no_sheets_book
min_books = red_book + green_book + blue_book
print(int(min_books))


(n, k) = map(int, input().split())
print(sum([n * nsheets // k + (n * nsheets % k > 0) for nsheets in (2, 5, 8)]))


(m, n) = map(int, input().split())
hr = 2 * m
hv = 5 * m
ha = 8 * m
contador = 0
cr = hr // n
contador = contador + cr
if hr % n > 0:
	contador = contador + 1
cv = hv // n
contador = contador + cv
if hv % n > 0:
	contador = contador + 1
ca = ha // n
contador = contador + ca
if ha % n > 0:
	contador = contador + 1
print(contador)


t = 0
n = list(map(int, input().split(' ')))
if n[0] * 2 % n[1] == 0:
	t += n[0] * 2 // n[1]
else:
	t += n[0] * 2 // n[1] + 1
if n[0] * 5 % n[1] == 0:
	t += n[0] * 5 // n[1]
else:
	t += n[0] * 5 // n[1] + 1
if n[0] * 8 % n[1] == 0:
	t += n[0] * 8 // n[1]
else:
	t += n[0] * 8 // n[1] + 1
print(t)


import math
(n, k) = input().split()
n = int(n)
k = int(k)
red = n * 2
green = n * 5
blue = n * 8
ans = red // k + green // k + blue // k
if red % k != 0:
	ans += 1
if green % k != 0:
	ans += 1
if blue % k != 0:
	ans += 1
print(ans)


(n, k) = input().split()
(n, k) = (int(n), int(k))
print((2 * n - 1) // k + (5 * n - 1) // k + (8 * n - 1) // k + 3)


(a, b) = map(int, input().split())
ans = 2 * a // b + (2 * a % b != 0) + 5 * a // b + (5 * a % b != 0) + 8 * a // b + (8 * a % b != 0)
print(int(ans))


import math
nnk = input()
nnk = nnk.split(' ')
n = int(nnk[0])
k = int(nnk[1])
result = math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k)
print(result)


(n, k) = map(int, input().split())
sum = 0
l = [2, 5, 8]
for i in range(3):
	t = l[i] * n
	if t % k != 0:
		sum += t // k + 1
	else:
		sum += t // k
print(sum)


tmp = input().split()
n = int(tmp[0])
k = int(tmp[1])
s = 0
if 2 * n % k == 0:
	s += int(2 * n / k)
else:
	s += int(2 * n / k) + 1
if 5 * n % k == 0:
	s += int(5 * n / k)
else:
	s += int(5 * n / k) + 1
if 8 * n % k == 0:
	s += int(8 * n / k)
else:
	s += int(8 * n / k) + 1
print(int(s))


def plusOne(n, k):
	if n % k != 0:
		return n // k + 1
	return n // k
(n, k) = [int(x) for x in input().split()]
v1 = n * 2
v2 = n * 5
v3 = n * 8
v1 = plusOne(v1, k)
v2 = plusOne(v2, k)
v3 = plusOne(v3, k)
print(v1 + v2 + v3)


import time

def calculateSheets(friends):
	(sred, sgreen, sblue) = (0, 0, 0)
	sred = friends * 2
	sgreen = friends * 5
	sblue = friends * 8
	return (sred, sgreen, sblue)

def calcNotebooks(redNdd, greenNdd, blueNdd, sheetpNBook):
	tNotebooks = 0
	(tred, tgreen, tblue) = (0, 0, 0)
	tred = redNdd // sheetpNBook
	if redNdd % sheetpNBook > 0:
		tred += 1
	tgreen = greenNdd // sheetpNBook
	if greenNdd % sheetpNBook > 0:
		tgreen += 1
	tblue = blueNdd // sheetpNBook
	if blueNdd % sheetpNBook > 0:
		tblue += 1
	tNotebooks = tred + tgreen + tblue
	return tNotebooks

def solve():
	(friends, sheetpNBook) = [int(x) for x in input().split()]
	(redNdd, greenNdd, blueNdd) = calculateSheets(friends)
	print(calcNotebooks(redNdd, greenNdd, blueNdd, sheetpNBook))
solve()


A = list(map(int, input().split()))
p = A[0]
q = A[1]
P = 2 * p // q
if 2 * p % q != 0:
	P = P + 1
Q = 5 * p // q
if 5 * p % q != 0:
	Q = Q + 1
R = 8 * p // q
if 8 * p % q != 0:
	R = R + 1
S = P + Q + R
print(S)


n = [int(i) for i in input().split()]
a = 0
for i in range(2, 9, 3):
	if n[0] * i % n[1] == 0:
		a += n[0] * i // n[1]
	else:
		a += n[0] * i // n[1] + 1
print(a)


(n, k) = map(int, input().split())
ans = 0
s = 2 * n
s1 = 5 * n
s2 = 8 * n
r = s // k
r1 = s1 // k
r2 = s2 // k
ans += r + r1 + r2
if s % k != 0:
	ans += 1
if s1 % k != 0:
	ans += 1
if s2 % k != 0:
	ans += 1
print(ans)


import math

def main():
	(n, k) = map(int, input().split())
	red = 2 * n
	green = 5 * n
	blue = 8 * n
	res = math.ceil(red / k) + math.ceil(green / k) + math.ceil(blue / k)
	print(res)
main()


import sys
import math, bisect
sys.setrecursionlimit(10 ** 5)
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, defaultdict

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

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

def Neo():
	return list(map(int, sys.stdin.readline().split()))
(n, k) = neo()
(r, g, b) = (n * 2, n * 5, n * 8)
Ans = math.ceil(r / k) + math.ceil(g / k) + math.ceil(b / k)
print(Ans)


import math

def principal():
	(n, k) = map(int, input().split())
	red = 2
	green = 5
	blue = 8
	nr = red * n
	ng = green * n
	nb = blue * n
	sumablocs = int(math.ceil(nr / k) + math.ceil(ng / k) + math.ceil(nb / k))
	print(sumablocs)
principal()


from sys import stdin
(fr, li) = [int(x) for x in stdin.readline().split()]
red = (fr * 2 + li - 1) // li
green = (fr * 5 + li - 1) // li
blue = (fr * 8 + li - 1) // li
print(red + green + blue)


from math import ceil
(friends, k) = input().split(' ')
friends = int(friends)
red = friends * 2
green = friends * 5
blue = friends * 8
red = ceil(red / int(k))
green = ceil(green / int(k))
blue = ceil(blue / int(k))
result = blue + green + red
print(result)


def countPieces(piece, k):
	if piece % k != 0:
		return int(piece / k) + 1
	return int(piece / k)
(n, k) = map(int, input().split())
redPices = 2 * n
greenPieces = 5 * n
bluePieces = 8 * n
kRedPieces = countPieces(redPices, k)
kGreenPieces = countPieces(greenPieces, k)
kBluePieces = countPieces(bluePieces, k)
print(kRedPieces + kGreenPieces + kBluePieces)


def calc(n, k, col):
	return (n * col + k - 1) // k
(n, k) = map(int, input().split())
ans = calc(n, k, 2) + calc(n, k, 5) + calc(n, k, 8)
print(ans)


(v, h) = list(map(int, input().split()))
red = v * 2
green = v * 5
blu = v * 8
cont = 0
if red % h > 0:
	cont += red // h + 1
else:
	cont += red // h
if green % h > 0:
	cont += green // h + 1
else:
	cont += green // h
if blu % h > 0:
	cont += blu // h + 1
else:
	cont += blu // h
print(cont)


(n, k) = tuple(map(int, input().split()))
co = 0
for i in [2 * n, 5 * n, 8 * n]:
	co += i // k
	if i % k != 0:
		co += 1
print(co)


(n, k) = map(int, input().split())
(a, b, c) = (2 * n, 5 * n, 8 * n)
res = 0
if a > 0:
	x = a / k
	if x % 1 > 0:
		x = int(x) + 1
	res += x
if b > 0:
	x = b / k
	if x % 1 > 0:
		x = int(x) + 1
	res += x
if c > 0:
	x = c / k
	if x % 1 > 0:
		x = int(x) + 1
	res += x
print(int(res))


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
(n, k) = map(int, input().split())
mx = 8 * n
mx2 = 5 * n
mx3 = 2 * n
if mx % k == 0:
	mx //= k
else:
	mx //= k
	mx += 1
if mx2 % k == 0:
	mx2 //= k
else:
	mx2 //= k
	mx2 += 1
if mx3 % k == 0:
	mx3 //= k
else:
	mx3 //= k
	mx3 += 1
print(mx + mx2 + mx3)


(n, k) = list(map(int, input().split()))
no_red = 2 * n
no_green = 5 * n
no_blue = 8 * n
req_red = no_red // k
req_green = no_green // k
req_blue = no_blue // k
if no_red % k != 0:
	req_red += 1
if no_green % k != 0:
	req_green += 1
if no_blue % k != 0:
	req_blue += 1
print(req_red + req_green + req_blue)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
r = 2 * n
g = 5 * n
b = 8 * n
if r % k == 0:
	nr = r / k
else:
	nr = r // k + 1
if g % k == 0:
	ng = g / k
else:
	ng = g // k + 1
if b % k == 0:
	nb = b / k
else:
	nb = b // k + 1
print(int(nr + ng + nb))


import math
(n, k) = map(int, input().split())
nr = 2 * n
ng = 5 * n
nb = 8 * n
total = math.ceil(nr / k) + math.ceil(ng / k) + math.ceil(nb / k)
print(total)


(n, k) = map(int, input().split())
(x, y, z) = (2, 5, 8)
S1 = x * n
S2 = y * n
S3 = z * n
res = 0
if S1 % k == 0:
	res += S1 // k
else:
	res += S1 // k + 1
if S2 % k == 0:
	res += S2 // k
else:
	res += S2 // k + 1
if S3 % k == 0:
	res += S3 // k
else:
	res += S3 // k + 1
print(res)


inp = input().split(' ')
n = int(inp[0])
k = int(inp[1])
red = n * 2 // k
if n * 2 % k != 0:
	red = red + 1
green = n * 5 // k
if n * 5 % k != 0:
	green = green + 1
blue = n * 8 // k
if n * 8 % k != 0:
	blue = blue + 1
ans = red + green + blue
print(ans)


import math
(n, k) = map(int, input().strip().split())
colors = [2, 5, 8]
res = 0
for c in colors:
	res += math.ceil(c * n / k)
print(res)


import math
inp = input()
(n, k) = [int(x) for x in inp.split(' ')]
(n8, n5, n2) = (n * 8, n * 5, n * 2)
print(math.ceil(n8 / float(k)) + math.ceil(n5 / float(k)) + math.ceil(n2 / float(k)))


(n, k) = list(map(int, input().split()))
r = n * 2
g = n * 5
b = n * 8
c = 0
if r <= k:
	c += 1
elif r % k == 0:
	c += r // k
else:
	c += r // k + 1
if g <= k:
	c += 1
elif g % k == 0:
	c += g // k
else:
	c += g // k + 1
if b <= k:
	c += 1
elif b % k == 0:
	c += b // k
else:
	c += b // k + 1
print(c)


import math

def main():
	(n, k) = (int(x) for x in input().split())
	solver(n, k)

def solver(n, k):
	redBooks = math.ceil(2 * n / k)
	greenBooks = math.ceil(5 * n / k)
	blueBooks = math.ceil(8 * n / k)
	books = redBooks + greenBooks + blueBooks
	print(books)
main()


(n, k) = map(int, input().split())

def find(k, div, n):
	return (k + div * n - 1) // k
print(find(k, 2, n) + find(k, 5, n) + find(k, 8, n))


import math
r = lambda : map(int, input().split())
(n, k) = r()
print(math.ceil(n * 2 / k) + math.ceil(n * 5 / k) + math.ceil(n * 8 / k))


(n, k) = [int(i) for i in input().split()]
r = 2
g = 5
b = 8
a1 = n * r // k
a2 = n * g // k
a3 = n * b // k
if n * r % k != 0:
	a1 += 1
if n * g % k != 0:
	a2 += 1
if n * b % k != 0:
	a3 += 1
print(a1 + a2 + a3)


(n, k) = map(int, input().split())
if 2 * n % k == 0:
	A = 2 * n // k
else:
	A = 2 * n // k + 1
if 5 * n % k == 0:
	B = 5 * n // k
else:
	B = 5 * n // k + 1
if 8 * n % k == 0:
	C = 8 * n // k
else:
	C = 8 * n // k + 1
print(A + B + C)


import math
(n, k) = input().split()
n = int(n)
k = int(k)
azN = n * 8
roN = n * 2
veN = n * 5
Raz = 0
Rro = 0
Rve = 0
if azN > k:
	Raz = azN / k
elif azN < k:
	Raz = 1
if roN > k:
	Rro = roN / k
elif roN < k:
	Rro = 1
if veN > k:
	Rve = veN / k
elif veN < k:
	Rve = 1
resultado = math.ceil(Raz) + math.ceil(Rro) + math.ceil(Rve)
print(resultado)


from math import ceil
(n, k) = map(int, input().split())
rn = n * 2
gn = n * 5
bn = n * 8
print('{}'.format(ceil(rn / k) + ceil(gn / k) + ceil(bn / k)))


import math as m
x = input()
a = int(x.split(' ')[0])
b = int(x.split(' ')[1])
RED = 2 * a
GREEN = 5 * a
BLUE = 8 * a
total = m.ceil(RED / b) + m.ceil(GREEN / b) + m.ceil(BLUE / b)
print(total)


(n, k) = list(map(int, input().split()))
count = 0
for i in [2, 5, 8]:
	count += (i * n + k - 1) // k
print(count)


(n, m) = map(int, input().split())
p = n * 2
q = n * 5
r = n * 8
if p % m == 0:
	a = int(p / m)
else:
	a = int(p / m) + 1
if q % m == 0:
	b = int(q / m)
else:
	b = int(q / m) + 1
if r % m == 0:
	c = int(r / m)
else:
	c = int(r / m) + 1
print(a + b + c)


(n, k) = map(int, input().split())
red = 2 * n
green = 5 * n
blue = 8 * n
if red % k == 0:
	numred = red // k
else:
	numred = red // k + 1
if green % k == 0:
	numgreen = green // k
else:
	numgreen = green // k + 1
if blue % k == 0:
	numblue = blue // k
else:
	numblue = blue // k + 1
num = numred + numgreen + numblue
print(num)


import math
NK = list(map(int, input().split()))
NRed = math.ceil(2 * NK[0] / NK[1])
NGreen = math.ceil(5 * NK[0] / NK[1])
NBlue = math.ceil(8 * NK[0] / NK[1])
print(NRed + NGreen + NBlue)


import math
(n, k) = input().split()
(n, k) = (int(n), int(k))
r = 2 * n
g = 5 * n
b = 8 * n
red = math.ceil(r / k)
green = math.ceil(g / k)
blue = math.ceil(b / k)
print(red + green + blue)


import math
red = 2
green = 5
blue = 8
(invite, notebook) = input().split()
invite = int(invite)
notebook = int(notebook)
redpages = red * invite
greenpages = green * invite
bluepages = blue * invite
redbook = math.ceil(redpages / notebook)
greenbook = math.ceil(greenpages / notebook)
bluebook = math.ceil(bluepages / notebook)
print(redbook + greenbook + bluebook)


a = input().split()
n = int(a[0])
m = int(a[1])
x = 0
a = n * 2
b = n * 5
c = n * 8
x += a // m + b // m + c // m
if a % m != 0:
	x += 1
if b % m != 0:
	x += 1
if c % m != 0:
	x += 1
print(x)


import sys

def rint():
	return map(int, sys.stdin.readline().split())
(n, k) = rint()
r = 2 * n
g = 5 * n
b = 8 * n
ans = r // k
if r % k:
	ans += 1
ans += g // k
if g % k:
	ans += 1
ans += b // k
if b % k:
	ans += 1
print(ans)


(m, n) = map(int, input().split())
v = m * 2
u = m * 5
w = m * 8
c = 0
if v % n == 0:
	c += v // n
else:
	c += v // n + 1
if u % n == 0:
	c += u // n
else:
	c += u // n + 1
if w % n == 0:
	c += w // n
else:
	c += w // n + 1
print(c)


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

def solve():
	(n, k) = input_ints()
	print((2 * n + k - 1) // k + (5 * n + k - 1) // k + (8 * n + k - 1) // k)
solve()


(n, k) = map(int, input().split())
r = 2
g = 5
b = 8
rbr = n * r // k
if n * r / k > rbr:
	rbr = rbr + 1
gbr = n * g // k
if n * g / k > gbr:
	gbr = gbr + 1
bbr = n * b // k
if n * b / k > bbr:
	bbr = bbr + 1
print(rbr + gbr + bbr)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
total = 0
r = 2 * n
g = 5 * n
b = 8 * n
total = int(r / k) + int(g / k) + int(b / k)
if r % k > 0:
	total += 1
if g % k > 0:
	total += 1
if b % k > 0:
	total += 1
print(total)


t = [int(x) for x in input().split()]
n = t[0]
k = t[1]
s = [2, 5, 8]
bl = 0
for ch in s:
	if k > ch * n:
		bl += 1
	elif ch * n % k == 0:
		bl += ch * n // k
	else:
		bl += ch * n // k + 1
print(bl)


(n, k) = (int(i) for i in input().strip().split())
ans = 2 * n // k + 5 * n // k + 8 * n // k
if 2 * n % k:
	ans += 1
if 5 * n % k:
	ans += 1
if 8 * n % k:
	ans += 1
print(ans)


(a, b) = map(int, input().split())
c = 0
for i in range(2, 9, 3):
	c += i * a // b
	if i * a % b != 0:
		c += 1
print(c)


(n, k) = map(int, input().split())
y = [2 * n, 5 * n, 8 * n]
z = 0
for i in y:
	if i < k:
		z += 1
	elif i % k == 0:
		z = z + i // k
	else:
		z = z + (i // k + 1)
print(z)


angka = input().split()
red = 2
green = 5
blue = 8
totalRed = int(angka[0]) * red
totalGreen = int(angka[0]) * green
totalBlue = int(angka[0]) * blue
a = int(angka[1])
b = int(angka[1])
c = int(angka[1])
if a < totalRed and totalRed % b != 0:
	hasil1 = totalRed // int(angka[1]) + 1
elif a < totalRed and totalRed % b == 0:
	hasil1 = totalRed // int(angka[1])
else:
	hasil1 = 1
if b < totalGreen and totalGreen % b != 0:
	hasil2 = totalGreen // int(angka[1]) + 1
elif b < totalGreen and totalGreen % b == 0:
	hasil2 = totalGreen // int(angka[1])
else:
	hasil2 = 1
if c < totalBlue and totalBlue % b != 0:
	hasil3 = totalBlue // int(angka[1]) + 1
elif c < totalBlue and totalBlue % b == 0:
	hasil3 = totalBlue // int(angka[1])
else:
	hasil3 = 1
total = hasil1 + hasil2 + hasil3
print(total)


(n, k) = [int(i) for i in input().split()]
r = 2
g = 5
b = 8
if r * n % k <= 0:
	d = r * n // k
else:
	d = r * n // k + 1
if g * n % k <= 0:
	e = g * n // k
else:
	e = g * n // k + 1
if b * n % k <= 0:
	f = b * n // k
else:
	f = b * n // k + 1
print(d + e + f)


(N, K) = map(int, input().split())
REQ1 = 2 * N
REQ2 = 5 * N
REQ3 = 8 * N
ans = REQ1 // K + REQ2 // K + REQ3 // K + bool(REQ1 % K) + bool(REQ2 % K) + bool(REQ3 % K)
print(ans)


a = list(map(int, input().split()))
l = 0
b = a[0] * 8
l = l + b // a[1]
if b % a[1] != 0:
	l += 1
b = a[0] * 5
l = l + b // a[1]
if b % a[1] != 0:
	l += 1
b = a[0] * 2
l = l + b // a[1]
if b % a[1] != 0:
	l += 1
print(l)


(n, k) = map(int, input().split())
cnt = 0
a = [2, 5, 8]
for i in range(3):
	total = 0
	total = n * a[i]
	if total % k == 0:
		cnt += total // k
	else:
		cnt += total // k + 1
print(cnt)


import math
giris = input()
giris_ogeleri = giris.split()
n = int(giris_ogeleri[0])
k = int(giris_ogeleri[1])
kirmizi_ihtiyaci = n * 2
yesil_ihtiyaci = n * 5
mavi_ihtiyaci = n * 8
kirmizi_defter = math.ceil(kirmizi_ihtiyaci / k)
yesil_defter = math.ceil(yesil_ihtiyaci / k)
mavi_defter = math.ceil(mavi_ihtiyaci / k)
print(kirmizi_defter + yesil_defter + mavi_defter)


import math
(n_str, k_str) = input().split(' ')
n = int(n_str)
k = int(k_str)
num_of_red_sheets = 2 * n
num_of_green_sheets = 5 * n
num_of_blue_sheets = 8 * n
num_of_red_notebooks = math.ceil(num_of_red_sheets / k)
num_of_green_notebooks = math.ceil(num_of_green_sheets / k)
num_of_blue_notebooks = math.ceil(num_of_blue_sheets / k)
total_notebooks = num_of_red_notebooks + num_of_green_notebooks + num_of_blue_notebooks
print(total_notebooks)


import math
string = input()
sheets = string.split(' ')
n = int(sheets[0])
k = int(sheets[1])
Red_sheets = 2 * n
Green_sheets = 5 * n
Blue_sheets = 8 * n
Total_Red = math.ceil(Red_sheets / k)
Total_Green = math.ceil(Green_sheets / k)
Total_Blue = math.ceil(Blue_sheets / k)
SUM = Total_Red + Total_Green + Total_Blue
print(SUM)


(m, n) = map(int, input().split())
red = 2 * m // n
green = 5 * m // n
blue = 8 * m // n
if 2 * m % n != 0:
	red += 1
if 5 * m % n != 0:
	green += 1
if 8 * m % n != 0:
	blue += 1
print(red + blue + green)


(n, k) = map(int, input().split())
red = 2 * n
green = 5 * n
blue = 8 * n
red_books = red // k
if red % k != 0:
	red_books += 1
green_books = green // k
if green % k != 0:
	green_books += 1
blue_books = blue // k
if blue % k != 0:
	blue_books += 1
print(red_books + green_books + blue_books)


from sys import stdin
(n, k) = [int(x) for x in stdin.readline().split()]
sheets = [2 * n, 5 * n, 8 * n]
count = 0
if k > 0 and n > 0:
	for elem in sheets:
		count = count + int(elem / k)
		if elem % k > 0:
			count = count + 1
print(count)


(a, b) = map(int, input().split())
q = a * 2 // b
w = a * 5 // b
e = a * 8 // b
if a * 2 % b != 0:
	q += 1
if a * 5 % b != 0:
	w += 1
if a * 8 % b != 0:
	e += 1
print(q + w + e)


(n, k) = [int(i) for i in input().split()]
if 2 * n % k == 0:
	R = 2 * n // k
else:
	R = 2 * n // k + 1
if 5 * n % k == 0:
	G = 5 * n // k
else:
	G = 5 * n // k + 1
if 8 * n % k == 0:
	B = 8 * n // k
else:
	B = 8 * n // k + 1
print(R + G + B)


import sys
(n, k) = [int(i) for i in sys.stdin.readline().strip().split()]
r = 8 * n // k + 5 * n // k + 2 * n // k + (8 * n % k != 0) + (5 * n % k != 0) + (2 * n % k != 0)
print(r)


(n, k) = [int(j) for j in input().split()]
import math
result = math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k)
print(result)


(n, k) = map(int, input().split())
req = [2, 5, 8]
sheets = [i * n for i in req]
total = 0
for i in sheets:
	if i % k != 0:
		total += i // k + 1
	else:
		total += i // k
print(total)


import math as ma
(a, b) = map(int, input().split())
r = ma.ceil(a * 2 / b)
g = ma.ceil(a * 5 / b)
b = ma.ceil(a * 8 / b)
print(int(r + g + b))


(n, m) = input().split(' ')
n = int(n)
m = int(m)
r = n * 2 // m
g = n * 5 // m
b = n * 8 // m
if n * 2 % m != 0:
	r += 1
if n * 5 % m != 0:
	g += 1
if n * 8 % m != 0:
	b += 1
print(r + g + b)


import math
x = [int(i) for i in input().split()]
(n, k) = (x[0], x[1])
print(math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k))


(n, k) = map(int, input().split())
res = 0
cur = n * 2
res += (cur + k - 1) // k
cur = n * 5
res += (cur + k - 1) // k
cur = n * 8
res += (cur + k - 1) // k
print(res)


import math
(n, k) = map(int, input().split())
red = (2 * n + k - 1) // k
green = (5 * n + k - 1) // k
blue = (8 * n + k - 1) // k
sm = red + green + blue
print(sm)


from math import ceil
redx = 2
greenx = 5
bluex = 8
books = 0
(n, k) = map(int, input().split())
redSheetsNeeded = n * redx
greenSheetsNeeded = n * greenx
blueSheetsNeeded = n * bluex
books += ceil(redSheetsNeeded / k)
books += ceil(greenSheetsNeeded / k)
books += ceil(blueSheetsNeeded / k)
print('{}'.format(books))


j = input().split()
n = int(j[0])
k = int(j[1])
a = 2 * n
b = 5 * n
c = 8 * n
import math
if a % k == 0:
	a = a / k
else:
	a = a / k
	a = math.floor(a) + 1
if b % k == 0:
	b = b / k
else:
	b = b / k
	b = math.floor(b) + 1
if c % k == 0:
	c = c / k
else:
	c = c / k
	c = math.floor(c) + 1
print(int(a + b + c))


(n, k) = input().split(' ')
(n, k) = (int(n), int(k))
f = lambda x: x * n // k + bool(x * n % k)
ans = f(2) + f(5) + f(8)
print(ans)


from math import ceil
import sys
(n, k) = map(int, sys.stdin.readline().split(' '))
result = 0
for sheets in (2, 5, 8):
	result += ceil(sheets * n / k)
print(result)


import sys
list1 = [2, 5, 8]
for line in sys.stdin:
	(n, k) = map(int, line.split())
	books = 0
	for x in range(len(list1)):
		list1[x] *= n
		books += (list1[x] + k - 1) // k
print(books)


import math
input = input()
(n, k) = input.split(' ')
n = int(n)
k = int(k)
red_pages = 0
green_pages = 0
blue_pages = 0
red_pages = n * 2
green_pages = n * 5
blue_pages = n * 8
red_notebooks = math.ceil(red_pages / k)
green_notebooks = math.ceil(green_pages / k)
blue_notebooks = math.ceil(blue_pages / k)
print(int(red_notebooks + green_notebooks + blue_notebooks))


(n, k) = map(int, input().split(' '))
n_red = 2 * n
n_green = 5 * n
n_blue = 8 * n
print((n_red - 1) // k + 1 + (n_green - 1) // k + 1 + (n_blue - 1) // k + 1)


def answer():
	a = [int(x) for x in input().split()]
	n = [2 * a[0], 5 * a[0], 8 * a[0]]
	c = [a[1], a[1], a[1]]
	i = 0
	ans = 0
	while i < len(n):
		ans += int(n[i] / c[i])
		ans += 1 * (n[i] % c[i] != 0)
		i += 1
	print(ans)
answer()


t = 1
while t > 0:
	t -= 1
	(n, k) = map(int, input().split())
	count = 0
	(b, r, g) = (8 * n, 2 * n, 5 * n)
	count += b // k + g // k + r // k
	if b % k > 0:
		count += 1
	if g % k > 0:
		count += 1
	if r % k > 0:
		count += 1
	print(count)


colors = (2, 5, 8)
(friends, pages_per_note) = map(int, input().split())

def color_counting(color):
	sheets = friends * color
	return sheets // pages_per_note + (sheets % pages_per_note > 0)
print(sum(map(color_counting, colors)))


(n, k) = map(int, input().split())
r_req = n * 2
g_req = n * 5
b_req = n * 8
if r_req % k == 0:
	no_r_books = r_req / k
else:
	no_r_books = r_req // k + 1
if g_req % k == 0:
	no_g_books = g_req / k
else:
	no_g_books = g_req // k + 1
if b_req % k == 0:
	no_b_books = b_req / k
else:
	no_b_books = b_req // k + 1
print(int(no_r_books + no_g_books + no_b_books))


import sys
from math import ceil

def main():
	(n, k) = map(int, sys.stdin.read().strip().split())
	return sum((int(ceil(i * n / k)) for i in (2, 5, 8)))
print(main())


import math
(n, k) = map(int, input().split())
r = int(math.ceil(n * 2 / k))
r1 = int(math.ceil(n * 8 / k))
r2 = int(math.ceil(n * 5 / k))
print(r + r1 + r2)


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
import sys
import math
MAX = sys.maxsize
MAXN = 10 ** 6 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

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

def charIN():
	return sys.stdin.readline().strip().split()
(n, k) = numIN()
tr = n * 2
tg = n * 5
tb = n * 8
ans = tr // k + tg // k + tb // k
if tr % k != 0:
	ans += 1
if tg % k != 0:
	ans += 1
if tb % k != 0:
	ans += 1
print(ans)


import math
(a, m) = list(map(int, input().split()))
r = a * 2
g = a * 5
b = 8 * a
print(math.ceil(r / m) + math.ceil(g / m) + math.ceil(b / m))


(a, b) = map(int, input().split())
ans = 0
if a * 2 % b == 0:
	ans = a * 2 // b
else:
	ans = a * 2 // b + 1
if a * 5 % b == 0:
	ans += a * 5 // b
else:
	ans += a * 5 // b + 1
if a * 8 % b == 0:
	ans += a * 8 // b
else:
	ans += a * 8 // b + 1
print(ans)


import math
(n, k) = input().split(' ')
n = int(n)
k = int(k)
red = n * 2
green = n * 5
blue = n * 8
temp = red / k
n_notebooks = math.ceil(temp)
temp = green / k
n_notebooks += math.ceil(temp)
temp = blue / k
n_notebooks += math.ceil(temp)
print(n_notebooks)


(n, k) = map(int, input().split())
red = n * 2
green = n * 5
blue = n * 8
ans = red // k + green // k + blue // k
if red % k > 0 or red // k == 0:
	ans += 1
if green % k > 0 or green // k == 0:
	ans += 1
if blue % k > 0 or blue // k == 0:
	ans += 1
print(ans)


import math
nk = list(map(int, input().rstrip().split()))
n = nk[0]
k = nk[1]
totalred = 2 * n
totalblue = 8 * n
totalgreen = 5 * n
redpages = math.ceil(totalred / k)
greenpages = math.ceil(totalgreen / k)
bluepages = math.ceil(totalblue / k)
print(redpages + bluepages + greenpages)


import math
(a, b) = map(int, input().split())
t1 = 0
t1 = math.ceil(a * 2 / b)
t1 += math.ceil(a * 5 / b)
t1 += math.ceil(a * 8 / b)
print(t1)


t = input()
(n, k) = t.split()
red = 2 * int(n)
gre = 5 * int(n)
blu = 8 * int(n)
tot = 0
if red / int(k) - red // int(k) == 0:
	tot += red // int(k)
else:
	tot += red // int(k) + 1
if gre / int(k) - gre // int(k) == 0:
	tot += gre // int(k)
else:
	tot += gre // int(k) + 1
if blu / int(k) - blu // int(k) == 0:
	tot += blu // int(k)
else:
	tot += blu // int(k) + 1
print(tot)


from math import ceil
(b, a) = map(int, input().split())
r = 2 * b
be = 5 * b
g = 8 * b
r = ceil(r / a) + ceil(be / a) + ceil(g / a)
print(r)


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

def num_notebooks(sheets, k):
	if sheets % k != 0:
		return sheets // k + 1
	else:
		return sheets // k
red_nb = num_notebooks(2 * n, k)
green_nb = num_notebooks(5 * n, k)
blue_nb = num_notebooks(8 * n, k)
print(int(red_nb + green_nb + blue_nb))


import math as m
(n, k) = map(int, input().split())
a = [2, 5, 8]
ans = m.ceil(a[0] * n / k) + m.ceil(a[1] * n / k) + m.ceil(a[2] * n / k)
print(ans)


(p, s) = [int(j) for j in input().split()]
l = [p * 2, p * 5, p * 8]
r = [int(i / s) + 1 if i % s > 0 else int(i / s) for i in l]
print(sum(r))


(n, k) = map(int, input().split())

def count(total, block):
	return (total - 1) // block + 1
print(sum((count(c * n, k) for c in (2, 5, 8))))


from math import ceil

def Origami():
	(n, k) = list(map(int, input().split()))
	redNeeded = 2 * n
	greenNeeded = 5 * n
	blueNeeded = 8 * n
	print(ceil(redNeeded / k) + ceil(greenNeeded / k) + ceil(blueNeeded / k))
Origami()


import math
(n, k) = [int(s) for s in input().split(' ')]
ans = (2 * n + k - 1) // k + (5 * n + k - 1) // k + (8 * n + k - 1) // k
print(ans)


str_n = input().split(' ')
n = int(str_n[0])
k = int(str_n[1])
count = 0
for i in [2, 5, 8]:
	if k == i * n or k > i * n:
		count += 1
	elif i * n > k and i * n % k == 0:
		count += i * n // k
	elif i * n > k:
		count += i * n // k + 1
print(count)


import math
(a, b) = input().split()
n = int(a)
k = int(b)
red = 2 * n
green = 5 * n
blue = 8 * n
red_note = math.ceil(red / k)
green_note = math.ceil(green / k)
blue_note = math.ceil(blue / k)
total = red_note + green_note + blue_note
print(total)


s = input()
n = s[0:s.find(' ')]
k = s[s.find(' '):len(s)]
red = int(n) * 2 // int(k)
green = int(n) * 5 // int(k)
blue = int(n) * 8 // int(k)
if int(n) * 2 % int(k):
	red += 1
if int(n) * 5 % int(k):
	green += 1
if int(n) * 8 % int(k):
	blue += 1
print(red + green + blue)


import math
(n, k) = list(map(int, input().strip().split()))
nor = n * 2
nog = n * 5
nob = n * 8
print(math.ceil(nor / k) + math.ceil(nog / k) + math.ceil(nob / k))


import math
(n, k) = map(int, input().split())
l = [2, 5, 8]
o = []
for i in l:
	o.append(i * n)
p = []
for i in o:
	p.append(math.ceil(i / k))
print(sum(p))


(a, b) = list(map(int, input().split()))

def jee(x, a):
	return x // a + int(x % a != 0)
print(jee(a * 2, b) + jee(a * 5, b) + jee(a * 8, b))


s = 0
(n, k) = map(int, input().split())
a = [2, 5, 8]
for x in range(len(a)):
	if a[x] * n % k == 0:
		s += a[x] * n // k
	else:
		s += a[x] * n // k + 1
print(s)


import math

def main():
	(n, k) = (int(x) for x in input().split())
	cnt = 0
	cnt += math.ceil(2 * n / k) + math.ceil(5 * n / k) + math.ceil(8 * n / k)
	print(cnt)
main()


import math

def numInvites(r, g, b):
	return 2 * r + 5 * g + 8 * b
(n, k) = input().split(' ')
n = float(n)
k = float(k)
totalSheets = n
nR = n * 2
nG = n * 5
nB = n * 8
res = int(math.ceil(nR / k) + math.ceil(nG / k) + math.ceil(nB / k))
print(res)


(n, k) = input().split()
n = int(n)
k = int(k)
c = n * k
h = n * 2
o = n * 5
l = n * 8
r = h // k
g = o // k
b = l // k
if h % k != 0:
	r = r + 1
if o % k != 0:
	g = g + 1
if l % k != 0:
	b = b + 1
z = r + g + b
print(z)


RED_SHEET = 2
GREEN_SHEET = 5
BLUE_SHEET = 8

def main():
	from math import ceil
	[n, k] = [int(x) for x in input().split()]
	red = ceil(RED_SHEET * n / k)
	green = ceil(GREEN_SHEET * n / k)
	blue = ceil(BLUE_SHEET * n / k)
	result = red + green + blue
	print(result)
main()


from collections import defaultdict

def read_line():
	return [int(x) for x in input().split()]
(n, k) = read_line()
from math import ceil
print(sum((ceil(n * c / k) for c in [2, 5, 8])))


arr = list(map(int, input().split()))
n = arr[0]
k = arr[1]
l = []
for i in range(2, 9, 3):
	s = n * i // k
	if n * i % k == 0:
		l.append(s)
	else:
		s = n * i // k + 1
		l.append(s)
print(sum(l))


(n, k) = list(map(int, input().split()))
print(-(-n * 2 // k) + -(-n * 5 // k) + -(-n * 8 // k))


import math
s = input().split()
n = int(s[0])
k = int(s[1])
total_notebooks = 0

def calc_notebooks(sheets, invites, notebook_size):
	return sheets * invites / notebook_size
for i in [2, 5, 8]:
	total_notebooks += math.ceil(calc_notebooks(i, n, k))
print(total_notebooks)


l = list(map(int, input().split()))
count = 0
a = [2, 5, 8]
for i in a:
	r = l[0] * i
	if r % l[1] == 0:
		count += r // l[1]
	else:
		count += r // l[1] + 1
print(count)


import math
inp = input().split(' ')
n = int(inp.pop(0))
k = int(inp.pop(0))
needred = 2 * n
needgreen = 5 * n
needblue = 8 * n
buyred = math.ceil(needred / k)
buygreen = math.ceil(needgreen / k)
buyblue = math.ceil(needblue / k)
print(buyred + buygreen + buyblue)


(n, k) = list(map(int, input().split()))
R = 2 * n
G = 5 * n
B = 8 * n
ans = (R + k - 1) // k + (G + k - 1) // k + (B + k - 1) // k
print(ans)


from sys import stdin, stdout
import math
import heapq
from itertools import accumulate
(N, K) = [int(x) for x in stdin.readline().split()]
R = N * 2
G = N * 5
B = N * 8
res = 0
res += N * 2 // K + 1 * (2 * N % K != 0)
res += N * 5 // K + 1 * (5 * N % K != 0)
res += N * 8 // K + 1 * (8 * N % K != 0)
print(res)


(n, k) = map(int, input().split(' '))
sheets = [2, 5, 8]
sol = 0
for i in sheets:
	sol += n * i // k
	if n * i % k:
		sol += 1
print(sol)


(n, k) = input().split()
n = int(n)
k = int(k)
p = 2 * n
q = 5 * n
r = 8 * n
a = p // k
b = q // k
c = r // k
w = a + b + c
if p % k == 0:
	if q % k == 0:
		if r % k == 0:
			z = w
			print(z)
		else:
			z = w + 1
			print(z)
	elif r % k == 0:
		z = w + 1
		print(z)
	else:
		z = w + 2
		print(z)
elif q % k == 0:
	if r % k == 0:
		z = w + 1
		print(z)
	else:
		z = w + 2
		print(z)
elif r % k == 0:
	z = w + 2
	print(z)
else:
	z = w + 3
	print(z)


(n, k) = map(int, input().split())
k1 = n * 2
if k1 % k != 0:
	k1 = k1 // k + 1
else:
	k1 = k1 // k
k2 = n * 5
if k2 % k != 0:
	k2 = k2 // k + 1
else:
	k2 = k2 // k
k3 = n * 8
if k3 % k != 0:
	k3 = k3 // k + 1
else:
	k3 = k3 // k
print(k1 + k2 + k3)


a = input().split(' ')
a1 = int(a[0])
a2 = int(a[1])
red = -(-(2 * a1) // a2)
grin = -(-(5 * a1) // a2)
blue = -(-(8 * a1) // a2)
print(red + grin + blue)


c = 0
a = []
s = input()
x = s.split()
a = [int(y) for y in x]
y = 2 * a[0]
r = 5 * a[0]
b = 8 * a[0]
c = y // a[1] + r // a[1] + b // a[1]
if y % a[1] != 0:
	c += 1
if r % a[1] != 0:
	c += 1
if b % a[1] != 0:
	c += 1
print(c)


import math
datos = input()
datos = datos.split(' ')
amigos = int(datos[0])
hojas = int(datos[1])
cuadernos = math.ceil(2 * amigos / hojas) + math.ceil(5 * amigos / hojas) + math.ceil(8 * amigos / hojas)
print(cuadernos)


(n, k) = map(int, input().split())
reds = 2 * n
greens = 5 * n
blues = 8 * n
ans = 0
ans += (reds + k - 1) // k
ans += (greens + k - 1) // k
ans += (blues + k - 1) // k
print(ans)


import math
inn = input()
f = int(inn.split(' ')[0])
c = int(inn.split(' ')[1])
a = [2, 5, 8]
print(sum([math.ceil(b * f / c) for b in a]))


import math

def solve():
	(n, k) = [int(x) for x in input().split(' ')]
	ans = int(math.ceil(n * 2 / k))
	ans += int(math.ceil(n * 5 / k))
	ans += int(math.ceil(n * 8 / k))
	print(ans)
solve()