PizzaForces is Petya's favorite pizzeria. PizzaForces makes and sells pizzas of three sizes: small pizzas consist of $6$ slices, medium ones consist of $8$ slices, and large pizzas consist of $10$ slices each. Baking them takes $15$, $20$ and $25$ minutes, respectively.

Petya's birthday is today, and $n$ of his friends will come, so he decided to make an order from his favorite pizzeria. Petya wants to order so much pizza that each of his friends gets at least one slice of pizza. The cooking time of the order is the total baking time of all the pizzas in the order.

Your task is to determine the minimum number of minutes that is needed to make pizzas containing at least $n$ slices in total. For example:

if $12$ friends come to Petya's birthday, he has to order pizzas containing at least $12$ slices in total. He can order two small pizzas, containing exactly $12$ slices, and the time to bake them is $30$ minutes;

if $15$ friends come to Petya's birthday, he has to order pizzas containing at least $15$ slices in total. He can order a small pizza and a large pizza, containing $16$ slices, and the time to bake them is $40$ minutes;

if $300$ friends come to Petya's birthday, he has to order pizzas containing at least $300$ slices in total. He can order $15$ small pizzas, $10$ medium pizzas and $13$ large pizzas, in total they contain $15 \cdot 6 + 10 \cdot 8 + 13 \cdot 10 = 300$ slices, and the total time to bake them is $15 \cdot 15 + 10 \cdot 20 + 13 \cdot 25 = 750$ minutes;

if only one friend comes to Petya's birthday, he can order a small pizza, and the time to bake it is $15$ minutes.


-----Input-----

The first line contains a single integer $t$ ($1 \le t \le 10^4$) — the number of testcases.

Each testcase consists of a single line that contains a single integer $n$ ($1 \le n \le 10^{16}$) — the number of Petya's friends.


-----Output-----

For each testcase, print one integer — the minimum number of minutes that is needed to bake pizzas containing at least $n$ slices in total.


-----Examples-----

Input
6
12
15
300
1
9999999999999999
3
Output
30
40
750
15
25000000000000000
15


-----Note-----

None

Source: codeforces | Difficulty: EASY
Tags: Mathematics

Complete search


Solutions:
for s in [*open(0)][1:]:
	print(max(6, int(s) + 1) // 2 * 5)


for s in [*open(0)][1:]:
	print(max(15, (int(s) + 1) // 2 * 5))


def solve():
	n = int(input())
	if n % 2:
		n += 1
	if n <= 6:
		print(15)
	else:
		print(5 * n // 2)
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	n = int(input())
	d = n // 6
	rem = n % 6
	ans = 15 if n < 6 else 0
	if d >= 1:
		ans = d * 15
		if 0 < rem < 3:
			ans += 5
		elif 3 <= rem < 5:
			ans += 10
		elif rem == 5:
			ans += 15
	else:
		ans = 15
	print(ans)


from sys import stdin, stderr

def rl():
	return [int(w) for w in stdin.readline().split()]
(t,) = rl()
for _ in range(t):
	(n,) = rl()
	print(max(n + 1, 7) // 2 * 5)


def pizzaForces(l):
	for el in l:
		if el <= 6:
			print(15)
		else:
			if el % 2 != 0:
				el += 1
			result = int(el * 2.5)
			resmod = result % 5
			if resmod < 3:
				result -= resmod
			else:
				result += 5 - resmod
			print(result)
t = int(input())
l = []
for i in range(t):
	l.append(int(input()))
pizzaForces(l)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 2 == 0:
		print(n // 2 * 5)
	else:
		print((n + 1) // 2 * 5)


import sys
I = sys.stdin
O = sys.stdout
inputs = [int(z) for z in I.readline().split()][0]
for _ in range(inputs):
	friends = [int(z) for z in I.readline().split()][0]
	if friends % 2 == 1:
		friends += 1
	O.write(str(max(friends, 6) // 2 * 5))
	O.write('\n')


import sys
input = sys.stdin.readline

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

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

def mps(A):
	return [tuple(map(int, input().split())) for _ in range(A)]
import math
import bisect
from copy import deepcopy as dc
from itertools import accumulate
from collections import Counter, defaultdict, deque

def ceil(U, V):
	return (U + V - 1) // V

def modf1(N, MOD):
	return (N - 1) % MOD + 1
inf = int(1e+20)
mod = int(1000000000.0 + 7)
t = int(input())
for _ in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 2 == 0:
		print(n * 5 // 2)
	else:
		n += 1
		print(n * 5 // 2)


for i in range(int(input())):
	n = int(input())
	n = abs(-n // 2)
	if n < 3:
		print(15)
	else:
		print(int(n * 5))


t = int(input())
for i in range(t):
	n = int(input())
	if n > 6:
		if n % 2 != 0:
			n += 1
		print(n * 5 // 2)
	else:
		print(15)


ans = 0
for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		ans = 15
	else:
		if n % 2 != 0:
			n += 1
		ans = n * 5 // 2
	print(ans)


t = int(input())
l = []
for i in range(t):
	n = int(input())
	y = n % 6
	x = int(n / 6)
	if n <= 6:
		c = 15
		l.append(c)
	else:
		if y == 1 or y == 2:
			c = x * 15 + 5
			l.append(c)
		if y == 3 or y == 4:
			c = x * 15 + 10
			l.append(c)
		if y == 5:
			c = (x + 1) * 15
			l.append(c)
		if y == 0:
			c = x * 15
			l.append(c)
for i in l:
	print(i)


t = int(input())
out = []
time = 0
for i in range(t):
	n = int(input())
	x = n % 10
	diff = x + 10
	x = int(n / 10) - 1
	if n % 6 == 0:
		out.append(15 * int(n / 6))
		continue
	elif n % 8 == 0:
		out.append(20 * int(n / 8))
		continue
	elif n % 10 == 0:
		out.append(25 * int(n / 10))
		continue
	elif n <= 6:
		out.append(15)
		continue
	elif n > 6 and n <= 8:
		out.append(20)
		continue
	elif n > 8 and n <= 10:
		out.append(25)
		continue
	elif diff <= 12:
		time = 30
	elif diff <= 14:
		time = 35
	elif diff <= 16:
		time = 40
	elif diff <= 18:
		time = 45
	elif diff <= 20:
		time = 50
	time = time + x * 25
	out.append(time)
for i in range(t):
	print(int(out[i]))


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	n = max(n, 6)
	n += 1
	print(n // 2 * 5)


import sys
input = sys.stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
for _ in range(I()):
	n = I()
	if n <= 6:
		print(15)
		continue
	ans = n // 6 * 15
	if n % 6:
		if n % 6 <= 2:
			ans = ans + 5
		elif n % 6 <= 4:
			ans = ans + 10
		else:
			ans += 15
	print(ans)


n = int(input())
l = []
res = []
for i in range(n):
	l.append(int(input()))
for i in l:
	mod = i % 6
	div = i // 6
	if mod == 0:
		res.append(i // 6 * 15)
	else:
		reste = (div + 1) * 6 - i
		if div >= 1:
			if reste == 1:
				res.append((div + 1) * 15)
			elif reste == 2:
				res.append((div - 1) * 15 + 25)
			elif reste == 3:
				res.append((div - 1) * 15 + 25)
			elif reste == 4:
				res.append((div - 1) * 15 + 20)
			elif reste == 5:
				res.append((div - 1) * 15 + 20)
		else:
			res.append(15)
print(*res, sep='\n')


from sys import stdin
input = stdin.readline
rn = lambda : int(input())
rns = lambda : map(int, input().split())
rl = lambda : list(map(int, input().split()))
rs = lambda : input().strip()
YN = lambda x: print('YES') if x else print('NO')
mod = 10 ** 9 + 7
from math import ceil
for _ in range(rn()):
	n = rn()
	if n < 7:
		print(15)
	elif n < 9:
		print(20)
	elif n < 11:
		print(25)
	else:
		ans = 2 * (n - (n & 1)) + n // 2
		ans += 5 * (n & 1)
		print(int(ans))


def main():
	t = int(input())
	while t > 0:
		n = int(input())
		if n % 2 != 0:
			n = n + 1
		if n > 6:
			print(n // 2 * 5)
		else:
			print(15)
		t -= 1
main()


import math
import sys
input = sys.stdin.readline
from math import ceil
t = int(input())
for _ in range(t):
	n = int(input())
	if n < 6:
		print(15)
		continue
	elif n % 6 == 0:
		print(15 * n // 6)
		continue
	elif n % 8 == 0:
		print(20 * n // 8)
		continue
	elif n % 10 == 0:
		print(25 * n // 10)
		continue
	cnt6 = n // 6 - 1
	ans = cnt6 * 15
	n -= cnt6 * 6
	if n <= 8:
		ans += 20
	elif n <= 10:
		ans += 25
	else:
		ans += 15 * math.ceil(n / 10)
	print(ans)


def calculate(n):
	if n <= 6:
		return 15
	elif n > 6 and n % 2 != 0:
		n += 1
		b = n // 2 * 5
		return b
	elif n > 6 and n % 2 == 0:
		b = n // 2 * 5
		return b
t = int(input())
l = []
for i in range(t):
	n = int(input())
	l.append(n)
for i in range(len(l)):
	print(calculate(l[i]))


def cal_min(val):
	if val <= 6:
		return 15
	if val / 2 == 0:
		val = val // 2 * 5
	else:
		val = val + 1
		val = val // 2 * 5
	return val
for _ in range(int(input())):
	val = int(input())
	print(cal_min(val))


def get_time(n):
	if n == 0:
		return 0
	elif 1 <= n <= 6:
		return 15
	total = 0
	total += n // 6 * 15
	n = n % 6
	if n == 0:
		return total
	elif 1 <= n <= 2:
		return total - 15 + 20
	elif 3 <= n <= 4:
		return total - 15 + 25
	return total + 15
num_cases = int(input())
cases = []
for i in range(num_cases):
	cases.append(int(input()))
for n in cases:
	print(get_time(n))


def f(n):
	if n < 6:
		return 15
	return (n + (n & 1)) // 2 * 5
testcase = int(input())
for i in range(testcase):
	n = int(input())
	print(f(n))


from fractions import Fraction
T = int(input())
for _ in range(T):
	N = int(input())
	if N % 2 == 1:
		N += 1
	N = Fraction(N)
	if N < 6:
		print(15)
	else:
		print(N / 2 * 5)


for _ in range(int(input())):
	n = int(input())
	print(max(6, n + 1) // 2 * 5)


t = int(input())
for _ in range(t):
	n = int(input())
	n = (n + 1) // 2
	if n <= 3:
		ans = 3 * 5
	else:
		ans = n * 5
	print(ans)


file = open(0)
(t, tcs) = (int(file.readline()), list(map(int, file.read().splitlines())))
for tc in tcs:
	if 0 < tc < 6:
		print('15')
		continue
	if tc % 2:
		print(int(tc // 2 * 5 + 5))
	else:
		print(int(tc // 2 * 5))


from math import ceil

def solve(n):
	res = 0
	res = n // 10 * 25
	r = n % 10
	if res > 0:
		res -= 25
		r += 10
	res += min(ceil(r / 10) * 25, ceil(r / 8) * 20, ceil(r / 6) * 15, ceil(r / 18) * 45, ceil(r / 16) * 40, ceil(r / 14) * 35)
	return res
test = int(input())
for t in range(test):
	n = int(input())
	print(solve(n))


def pizza(x):
	if x <= 6:
		time = 15
	else:
		time = x // 6 * 15
		if x % 6 == 1 or x % 6 == 2:
			time += 5
		elif x % 6 == 3 or x % 6 == 4:
			time += 10
		elif x % 6 == 5:
			time += 15
	return print(int(time))
testnum = int(input())
k = 0
testlist = []
while k < testnum:
	testlist.append(int(input()))
	k += 1
for ele in testlist:
	pizza(ele)


import sys
input = sys.stdin.readline
t = int(input())
while t > 0:
	n = int(input())
	print(max(6, n + 1) // 2 * 5)
	t -= 1


t = int(input())
result = []
for i in range(t):
	r = 0
	n = int(input().strip())
	if n <= 6:
		r = 15
	elif n % 2 == 0:
		r = n * 5 // 2
	else:
		r = (n + 1) * 5 // 2
	result.append(r)
for i in result:
	print(i)


t = int(input())
while t != 0:
	n = int(input())
	if n <= 6:
		ans = 15
	else:
		if n % 2 != 0:
			n = n + 1
		ans = n * 5 // 2
	print(ans)
	t = t - 1


def entrada():
	test_case = int(input())
	friends = list()
	for i in range(test_case):
		friends.append(int(input()))
	runcode(friends)

def runcode(lisst):
	for _ in lisst:
		print(int(pizzaForce(_)))

def pizzaForce(num):
	if num < 6:
		return 15
	elif num % 2 == 0:
		return int(num / 2) * 5
	else:
		return int((num + 1) / 2) * 5
entrada()


t = int(input())
for i in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	elif n < 9:
		print(20)
	elif n == 9:
		print(25)
	elif n % 2 == 0:
		print(n // 2 * 5)
	else:
		print((n // 2 + 1) * 5)


import sys
import math
input = sys.stdin.readline
T = int(input())
for _ in range(T):
	n = int(input())
	ans = 0
	if n <= 6:
		ans = 15
	else:
		if n % 2 != 0:
			n += 1
		ans = n * 5 // 2
	print(ans)


y = int(input())
for _ in range(y):
	x = int(input())
	n = x // 6
	k = x % 6
	if k == 0:
		print(max(15, n * 15))
	elif k <= 2:
		print(max(15, (n - 1) * 15 + 20))
	elif k <= 4:
		print(max(15, (n - 1) * 15 + 25))
	else:
		print(max(15, (n + 1) * 15))


for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 2 == 0:
		print(n * 2 + n // 2)
	else:
		n += 1
		print(n * 2 + n // 2)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	if n <= 6:
		print(15)
		continue
	print(5 * (n + n % 2) // 2)


t = int(input())
for i in range(t):
	friend = int(input())
	print(max(15, (friend + 1) // 2 * 5))


for a0 in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	else:
		if n % 2 == 1:
			n += 1
		n *= 25
		n //= 10
		print(n)


try:
	import sys
	import math
	import collections
	M = 10 ** 9 + 7

	def solve():
		x = int(input())
		if x <= 6:
			return 15
		elif x % 2 == 0:
			return 5 * x // 2
		else:
			return 5 * (x + 1) // 2
		temp = modularExponentiation(2, n) - 1
		return modularExponentiation(temp, k)
	test = int(input())
	count1 = 1
	while count1 <= test:
		ans = solve()
		sys.stdout.write(str(ans) + '\n')
		count1 += 1
except EOFError:
	print('')


def main(n):
	if n <= 6:
		return 15
	if n % 2 == 0:
		return n * 5 // 2
	return (n + 1) * 5 // 2
for _ in range(int(input())):
	print(main(int(input())))


n = int(input())
l2 = []
for i in range(n):
	l2.append(int(input()))
for i in l2:
	if i % 2 != 0:
		i = i + 1
	if i <= 6:
		print(15)
	else:
		print(5 * i // 2)


for _ in range(int(input())):
	n = int(input())
	ans = 25 * (n // 10)
	if n > 10 and n % 10 != 0:
		n = n % 10
		n += 10
		ans -= 25
	else:
		n = n % 10
	if n == 0:
		pass
	elif n >= 8:
		if n == 19 or n == 9:
			ans += 25 + 25 * (n // 10)
		elif n == 18 or n == 8:
			ans += 20 + 25 * (n // 10)
		elif n <= 12:
			ans += 30
		elif n <= 14:
			ans += 35
		else:
			ans += 25
			n -= 10
			if n > 6:
				ans += 20
			else:
				ans += 15
	elif n > 6:
		ans += 20
	else:
		ans += 15
	print(ans)


def solve(n):
	if n <= 6:
		return 15
	return (n + 1) // 2 * 5
s = ''
for case in range(int(input())):
	n = int(input())
	s += str(solve(n)) + '\n'
print(s)


import math
for _ in range(int(input())):
	n = int(input())
	fac = n // 6
	rem = n % 6
	if n <= 6:
		print(15)
		continue
	elif n <= 8:
		print(20)
		continue
	elif n <= 10:
		print(25)
		continue
	if n % 6 == 0:
		print(15 * fac)
	elif rem >= 3 and rem < 5:
		print(15 * (fac - 1) + 25)
	elif rem > 0 and rem <= 2:
		print(15 * (fac - 1) + 20)
	elif rem == 5:
		fac = math.ceil(n / 6)
		print(15 * fac)


import math
t = int(input())
for _ in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 2 == 1:
		n += 1
		print(math.floor(n * 20 // 8))
	else:
		print(math.floor(n * 20 // 8))


def minimumTime(x):
	a = x // 6
	r = x % 6
	if x <= 6:
		return 15
	elif r == 0:
		return a * 15
	elif r != 0 and r <= 2:
		return a * 15 + 5
	elif r != 0 and r <= 4:
		return a * 15 + 10
	else:
		return (a + 1) * 15
n = int(input())
testCase = []
for _ in range(n):
	e = int(input())
	testCase.append(e)
ans = []
for i in range(n):
	ans.append(minimumTime(testCase[i]))
	print(ans[i])


t = int(input())
for h in range(t):
	n = int(input())
	if n < 6:
		print(15)
	elif n % 2 == 0:
		print(5 * n // 2)
	else:
		print(5 * (n + 1) // 2)


import sys, math, cmath, time, collections
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import nsmallest, nlargest, heapify, heappop, heappush, heapreplace
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi
from bisect import bisect_left, bisect_right

def input_as_array():
	return list(map(int, input().split()))
start_time = time.time()

def solve(n):
	while n < 6 or n % 2 != 0:
		n += 1
	print(n // 2 * 5)

def main():
	n = int(input())
	solve(n)
LOCAL = False
if LOCAL:
	sys.stdin = open('../io/data.in', 'r')
	sys.stdout = open('../io/data.out', 'w')
testcases = int(input())
for i in range(testcases):
	main()
if LOCAL:
	print(f'Time Elapsed: {time.time() - start_time} seconds')
	sys.stdout.close()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = n // 6
	b = c = 0
	temp = n % 6
	while temp > 0 and a > 0:
		if temp == 5:
			a += 1
			temp -= 5
		elif temp >= 3:
			c += 1
			a -= 1
			temp -= 4
		elif temp >= 1:
			b += 1
			a -= 1
			temp -= 2
	if temp > 0:
		a += 1
	print(a * 15 + b * 20 + c * 25)


t = int(input())

def funn(n):
	if n <= 5:
		return 15
	if n % 2 == 1:
		x = n // 2 + 1
	else:
		x = n // 2
	return 5 * x
for _ in range(t):
	n = int(input())
	print(funn(n))


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

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		if n < 6:
			print(15)
			continue
		else:
			print(ceil(n, 2) * 5)
main()


from sys import *
input = stdin.readline
from bisect import *
import math
from collections import *
import operator
from heapq import *
from itertools import *
inf = 10 ** 18
mod = 10 ** 9 + 7
for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
		continue
	maxx = inf
	temp = n // 6 * 15
	rem = n % 6
	if rem <= 2 and rem:
		temp += 5
	elif rem <= 4 and rem:
		temp += 10
	elif rem:
		temp += 15
	print(temp)


t = int(input())
for j in range(t):
	n = int(input())
	if n <= 6:
		print('15')
		continue
	d = (n + 1) // 2 * 5
	print(d)


import sys
input = iter(sys.stdin.read().splitlines()).__next__

def solve(N):
	if N < 6:
		return 15
	m6 = N // 6
	rem = N % 6
	if rem == 0:
		return m6 * 15
	elif rem == 1 or rem == 2:
		return (m6 - 1) * 15 + 20
	elif rem == 3 or rem == 4:
		return (m6 - 1) * 15 + 25
	elif rem == 5:
		return (m6 + 1) * 15
TC = int(input())
for tc in range(TC):
	N = int(input())
	res = solve(N)
	print(res)


t = int(input())
testcases = [int(input()) for _ in range(t)]
for n in testcases:
	if n <= 6:
		print(15)
		continue
	n = (n + 1) // 2
	print(5 * n)


import sys, math

def solve():
	n = int(input())
	if n < 6:
		val1 = 15
	else:
		if n % 2 != 0:
			n += 1
		val1 = n * 5 // 2
	print(val1)
t = int(input())
while t != 0:
	solve()
	t -= 1


t = int(input())
for i in range(t):
	a = int(input())
	if a % 2 != 0:
		a += 1
	r = a // 2 * 5
	if r <= 15:
		print(15)
	else:
		print(r)


x = int(input())
for i in range(x):
	y = int(input())
	if y <= 6:
		print(15)
	else:
		print((y + 1) // 2 * 5)


for res in [*open(0)][1:]:
	print(max(15, (int(res) + 1) // 2 * 5))


def solve():
	n = int(input())
	print(max((n + 1) // 2, 3) * 5)
t = int(input())
for __ in range(t):
	solve()


t = int(input())
for case in range(0, t):
	n = int(input())
	if n < 6:
		print(15)
	else:
		print((n + n % 2) // 2 * 5)


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007

def solve(n):
	if n <= 6:
		print(15)
	else:
		ans = n // 6 * 15
		n = n % 6
		if n != 0:
			if n <= 2:
				print(ans + 5)
			else:
				print(ans + 10)
		else:
			print(ans)
for _ in range(int(input())):
	n = int(input())
	if n % 2 != 0:
		n += 1
	solve(n)


pizzas = [(6, 15), (8, 20), (10, 25)]
ans = [1000 for _ in range(121)]
ans[0] = 0
for i in range(1, 121):
	for (count, cost) in pizzas:
		if i <= count:
			ans[i] = min(ans[i], cost)
		else:
			ans[i] = min(ans[i], ans[i - count] + cost)
t = int(input())
while t > 0:
	n = int(input())
	jwb = n // 120 * ans[120] + ans[n % 120]
	for k in range(min(n, 120)):
		new_n = n - k
		jwb = min(jwb, new_n // 120 * ans[120] + ans[new_n % 120] + ans[k])
	print(jwb)
	t -= 1


t = int(input())
for _ in range(t):
	n = int(input())
	temp = n // 120
	ans = 1000000000
	if n <= 120:
		m = n % 120
		for i in range(0, 21):
			for j in range(0, 16):
				for k in range(0, 13):
					s = i * 6 + j * 8 + k * 10
					if s >= m:
						cost = i * 15 + j * 20 + k * 25
						ans = min(ans, cost)
						break
		print(ans + temp * 300)
	else:
		temp -= 1
		m = n % 120
		m = m + 120
		for i in range(0, 42):
			for j in range(0, 32):
				for k in range(0, 26):
					s = i * 6 + j * 8 + k * 10
					if s >= m:
						cost = i * 15 + j * 20 + k * 25
						ans = min(ans, cost)
						break
		print(ans + temp * 300)


for _ in range(int(input())):
	n = int(input())
	veer_G = n % 6
	if n // 6 == 0:
		print(15)
	elif veer_G >= 5:
		print((n // 6 + 1) * 15)
	elif veer_G == 3 or veer_G == 4:
		print((n // 6 - 1) * 15 + 25)
	elif veer_G == 2 or veer_G == 1:
		print((n // 6 - 1) * 15 + 20)
	elif veer_G == 0:
		print(n // 6 * 15)


import math as m
import sys
for _ in range(int(input())):
	n = int(sys.stdin.readline())
	if n <= 6:
		print(15)
		continue
	x = n // 6
	y = n % 6
	if y == 1 or y == 2:
		ans = str((x - 1) * 15 + 20)
	elif y == 4 or y == 3:
		ans = str((x - 1) * 15 + 25)
	elif y == 5:
		ans = str((x + 1) * 15)
	else:
		ans = str(x * 15)
	print(ans)


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	if n <= 10:
		if n <= 6:
			return 15
		elif n <= 8:
			return 20
		else:
			return 25
	r = n % 10
	if r == 0:
		return 25 * (n // 10)
	elif r <= 2:
		return 30 + 25 * ((n - 10) // 10)
	elif r <= 4:
		return 35 + 25 * ((n - 10) // 10)
	elif r <= 6:
		return 15 + 25 * (n // 10)
	elif r <= 8:
		return 20 + 25 * (n // 10)
	else:
		return 25 * (n // 10 + 1)
for _ in range(int(input())):
	print(solve())


import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def LI1():
	return list(map(int1, sys.stdin.readline().split()))

def LLI1(rows_number):
	return [LI1() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline().rstrip()
inf = 10 ** 16
md = 10 ** 9 + 7

def solve():
	n = II()
	if n <= 6:
		return 15
	elif n % 2 == 1:
		return int((n + 1) // 2 * 5)
	else:
		return int(n // 2 * 5)
for _ in range(II()):
	print(int(solve()))


iteration = int(input())
while iteration != 0:
	iteration = iteration - 1
	inp = int(input())
	small = 0
	medium = 0
	large = 0
	if inp <= 6:
		small += 1
	else:
		if inp % 2 != 0:
			inp += 1
		large = inp // 10
		if inp % 10 == 2:
			small = 2
			large = large - 1
		if inp % 10 == 4:
			small = 1
			medium = 1
			large = large - 1
		if inp % 10 == 6:
			small += 1
		if inp % 10 == 8:
			medium += 1
	time = small * 15 + medium * 20 + large * 25
	print(time)


import math

def main():
	t = int(input())
	for _ in range(t):
		print(case())

def case():
	n = int(input())
	if n <= 6:
		return 15
	if n % 6 == 0 or n % 8 == 0 or n % 10 == 0:
		return n * 2 + n // 2
	if n % 6 <= 2:
		return int(n // 6 * 15 - 15 + 20)
	elif n % 6 <= 4:
		return int(n // 6 * 15 - 15 + 25)
	else:
		return int(n // 6 * 15 + 15)
main()


for i in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 6 == 0:
		print(n * 15 // 6)
	elif n % 6 == 1 or n % 6 == 2:
		print(n // 6 * 15 + 5)
	elif n % 6 == 3 or n % 6 == 4:
		print(n // 6 * 15 + 10)
	elif n % 6 == 5:
		print(n // 6 * 15 + 15)


from math import *
from collections import defaultdict as dt
from sys import stdin
inp = lambda : stdin.readline().strip()
I = lambda : int(inp())
M = lambda : map(int, inp().split())
L = lambda : list(M())
mod = 1000000007
inf = 100000000000000000000
ss = 'abcdefghijklmnopqrstuvwxyz'

def solve():
	n = I()
	x = n // 6
	y = n // 8
	z = n // 10
	p = n % 6
	q = n % 8
	r = n % 10
	if n <= 6:
		print(15)
	elif n % 6 == 0:
		print(15 * (n // 6))
	elif n % 8 == 0:
		print(20 * (n // 8))
	elif n % 10 == 0:
		print(25 * (n // 10))
	elif p == 1:
		print(15 * (x - 1) + 20)
	elif p == 2:
		print(15 * (x - 1) + 20)
	elif p == 3 or p == 4:
		print(15 * (x - 1) + 25)
	else:
		print(15 * (x + 1))
tt = 1
tt = I()
for _ in range(tt):
	solve()


import math
for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	else:
		a = n // 6
		c = a * 15
		if n % 6:
			c += math.ceil(n % 6 / 2) * 5
		print(c)


from itertools import permutations, combinations, combinations_with_replacement
from bisect import bisect_left, bisect_right
from typing import List
from math import ceil, floor, gcd, sqrt
from itertools import accumulate

def prefix_sum(arr):
	prefix_sum = accumulate(arr)
	return [i for i in prefix_sum]
tt = int(input())
for _ in range(tt):
	n = int(input())
	ans = 0
	if n <= 6:
		print(15)
	elif n % 2 == 0:
		print(n * 5 // 2)
	else:
		print((n + 1) * 5 // 2)


def cal1(n):
	if n % 6 == 0:
		time = n // 6 * 15
	elif n % 8 == 0:
		time = n // 8 * 20
	elif n % 10 == 0:
		time = n // 10 * 25
	elif n % 8 == 6:
		time = n // 8 * 20
		time += 15
	elif n < 6:
		time = 15
	elif n < 8:
		time = 20
	elif n < 10:
		time = 25
	elif n < 12:
		time = n // 6 * 15
		if n % 6 > 0:
			time += 15
	elif n < 15:
		time = n // 8 * 20
		if n % 8 > 0:
			time += 15
	else:
		time = n // 10 * 25
		rod = n % 10
		if rod >= 9:
			time += 25
		elif rod > 6:
			time += 20
		elif rod > 0:
			time += 15
	return time

def cal(n):
	if n <= 6:
		return 15
	elif n % 2 == 0:
		return n // 2 * 5
	else:
		return n // 2 * 5 + 5
n = int(input())
d = []
for i in range(n):
	x = int(input())
	time = str(cal(x))
	d.append(time)
print('\n'.join(d))


count = int(input())
list_1 = [6, 8, 10]
list_2 = [15, 20, 25]
for _ in range(count):
	a = int(input())
	if a % 10 == 0:
		a = a // 10 * 25
		print(a)
	elif a < 15:
		if a <= 6:
			print(15)
		elif 6 < a <= 8:
			print(20)
		elif 8 < a < 11:
			print(25)
		elif 8 < a < 13:
			print(30)
		else:
			print(35)
	else:
		e = a // 10
		e_1 = a - e * 10 + 10
		e -= 1
		if 10 < e_1 < 13:
			print(25 * e + 30)
		if 12 < e_1 < 15:
			print(25 * e + 35)
		if 14 < e_1 < 17:
			print(25 * e + 40)
		if 16 < e_1 < 19:
			print(25 * e + 45)
		if 18 < e_1:
			print(25 * e + 50)


def exec():
	m = []
	t = int(input())
	for i in range(t):
		m.append(int(input()))
	for i in m:
		print(main(i))

def main(x):
	q = x // 6
	r = x % 6
	if q < 1:
		return 15
	elif r == 0:
		return q * 15
	elif r <= 2:
		return 15 * q + 5
	elif r <= 4:
		return 15 * q + 10
	else:
		return 15 * (q + 1)
exec()


import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]

def next():
	return tokens.pop()

def nextInt():
	return int(next())

def nextFloat():
	return float(next())

def getIntArray(n):
	return [nextInt() for _ in range(n)]

def getFloatArray(n):
	return [nextFloat() for _ in range(n)]

def getStringArray(n):
	return [next() for _ in range(n)]
flush = sys.stdout.flush
testcase = True

def solve(testcase):
	N = nextInt()
	if N % 2 == 1:
		N += 1
	N = max(N, 6)
	print(N * 5 // 2)
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
	solve(tc + 1)
assert not tokens


t = int(input())
for _ in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	else:
		x = n // 2
		if n % 2 != 0:
			x += 1
		print(x * 5)


import sys, os, time
from math import log, sqrt, floor
from os import path
import math
oj = True
if path.exists('inp.txt'):
	print('YES')
	sys.stdin = open('inp.txt', 'r')
	sys.stdout = open('out.txt', 'w')
	oj = False
mod = 1000000007
INF = float('inf')

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

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

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

def is_power_two(x):
	return x ^ x - 1 & x == x

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

def seive():
	(primes[0], primes[1]) = (False, False)
	for i in range(2, maxN + 1):
		for j in range(i * i, maxN + 1, i):
			if primes[j]:
				primes[j] = False

def power_2(n):
	return 1 << n

def ceil(a, b):
	return int((a + b - 1) / b)

def isPerfectSquare(x):
	if x >= 0:
		sr = sqrt(x)
		return sr * sr == x
	return false

def john3_16():
	n = readint()
	ans = float('inf')
	if n <= 6:
		ans = 15
	else:
		if n & 1:
			n += 1
		ans = min(ans, n * 5 // 2)
	print(ans)
	return

def main():
	tc = readint()
	start = time.time()
	while tc:
		john3_16()
		tc -= 1
	if not oj:
		total = time.time() - start
		print(str(total * 1000) + 'ms')
main()


N = int(input())
for i in range(N):
	t = int(input())
	if t % 2 == 1:
		t += 1
	print(max(6, t) // 2 * 5)


for _ in range(int(input())):
	n = int(input())
	m = (n + 1) // 2
	print(m * 5 if m >= 3 else 15)


t = int(input())
m = []
for i in range(t):
	n = int(input())
	if n <= 6:
		m.append(15)
	elif n % 2 == 1:
		n += 1
		m.append(n // 2 * 5)
	else:
		m.append(n // 2 * 5)
for num in m:
	print(num)


import math
import sys
import itertools
import fractions
wtf = sys.stdin.read()
wtf = wtf.strip().split('\n')
t = int(wtf[0])
for s in wtf[1:]:
	n = int(s)
	if n % 2 != 0:
		n += 1
	if n <= 6:
		print('15')
	else:
		print(int(n // 2 * 5))


inputs = []
while True:
	try:
		line = input()
	except EOFError:
		break
	inputs.append(line)
t = inputs[0]
for i in range(1, int(t) + 1):
	if int(inputs[i]) <= 6:
		print(15)
	else:
		print((int(inputs[i]) + 1) // 2 * 5)


def pizza(n):
	if n % 2:
		n += 1
	return int(max(n, 6) // 2 * 5)
t = int(input())
for i in range(t):
	n = int(input())
	print(pizza(n))


for _ in range(int(input())):
	x = int(input())
	if x < 6:
		print(15)
		continue
	if x % 2 == 1:
		x += 1
	x //= 2
	print(x * 5)


import math
for _ in range(int(input())):
	n = int(input())
	fac = n // 6
	rem = n % 6
	if n <= 6:
		print(15)
	else:
		if n % 2 != 0:
			n += 1
		print(n * 5 // 2)


import sys
from bisect import bisect_left as lb
from collections import deque
from queue import PriorityQueue as pq
from math import *
input_ = lambda : sys.stdin.readline().strip('\r\n')
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab, bc, cd: ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x: print(x)
prinT = lambda x: print(x)
f = lambda : sys.stdout.flush()
inv = lambda x: pow(x, mod - 2, mod)
mod = 10 ** 9 + 7
for _ in range(ii()):
	n = ii()
	if n <= 6:
		print(15)
		continue
	if n % 6 == 0:
		print(15 * (n // 6))
	elif n % 8 == 0:
		print(20 * (n // 8))
	elif n % 10 == 0:
		print(25 * (n // 10))
	elif n % 2 != 0:
		n += 1
		print(n // 2 * 5)
	else:
		print(n // 2 * 5)


for i in range(int(input())):
	a = int(input())
	print((a + a % 2) * 25 // 10 if a > 6 else 15)


def solve():
	n = int(input())
	if n <= 6:
		print(15)
	else:
		x = n // 6
		if n % 6 == 0:
			ans = x * 15
		elif n % 6 > 0 and (n % 6 == 1 or n % 6 == 2):
			x -= 1
			ans = x * 15 + 20
		elif n % 6 > 0 and (n % 6 == 3 or n % 6 == 4):
			x -= 1
			ans = x * 15 + 25
		else:
			x += 1
			ans = x * 15
		print(ans)
t = int(input())
while t != 0:
	solve()
	t -= 1


from decimal import Decimal
testcases = int(input())
list_cases = []
for x in range(testcases):
	list_cases.append(int(input()))
for i in list_cases:
	if i < 6:
		print(int(6 * Decimal(2.5)))
		continue
	elif i % 2:
		print(round((i + 1) * Decimal(2.5)))
	else:
		print(round(i * Decimal(2.5)))


import sys, math, io, os, time, itertools, collections
mod = 10 ** 9 + 7
sys.setrecursionlimit(10000)
i = sys.stdin.readline
p = sys.stdout.write
global start, end

def isin(l, x):
	left = 0
	right = len(l) - 1
	if x < l[0]:
		return -1
	while left <= right:
		mid = left + (right - left) // 2
		if l[mid] == x:
			return mid
		elif l[mid] < x:
			ans = mid
			left = mid + 1
		else:
			right = mid - 1
	return ans

def ispal(l):
	n = len(l)
	for i in range(n // 2 + 1):
		if l[i] != l[n - i - 1]:
			return False
	return True

def ccarray(l):
	d = {l[k]: k for k in range(len(l))}
	m = sorted(d)
	return [d[m[k]] for k in range(len(l))]

def is_prime(n):
	if n <= 3:
		return n > 1
	if n % 2 == 0 or n % 3 == 0:
		return False
	k = 5
	while k ** 2 <= n:
		if n % k == 0 or n % (k + 2) == 0:
			return False
		k += 6
	return True

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

def main():
	n = int(i())
	if n & 1:
		n += 1
	n = n // 2
	(x, y, z) = (0, 0, 0)
	if n == 1 or n == 2:
		x = 1
	elif n % 3 == 1:
		y = 1
		x = (n - 4) // 3
	elif n % 3 == 2:
		z = 1
		x = (n - 5) // 3
	else:
		x = n // 3
	ans = (6 * x + 8 * y + 10 * z) * 5 // 2
	p(str(ans) + '\n')
t = 1
t = int(i())
start = time.perf_counter()
for _ in range(t):
	main()
end = time.perf_counter()


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
import string
ORDA = 97

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

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

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

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

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

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

def divs(n, start=2):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	new_number = 0
	while number > 0:
		new_number += number % base
		number //= base
	return new_number

def cdiv(n, k):
	return n // k + (n % k != 0)

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True
for _ in range(ii()):
	n = ii()
	if n < 7:
		print(15)
	elif n % 6 == 0:
		print(n // 6 * 15)
	elif n % 6 < 3:
		print((n // 6 - 1) * 15 + 20)
	elif n % 6 < 5:
		print((n // 6 - 1) * 15 + 25)
	else:
		print(n // 6 * 15 + 15)


import sys
from math import ceil, floor, modf, sqrt
from collections import deque

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

def get_array():
	return list(get_ints())

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

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def findans(n):
	if n <= 6:
		return 15
	times = n // 6
	firstcost = (times - 1) * 15
	rem = 6 + n % 6
	seccost = 0
	if rem == 6 or rem == 12 or rem == 11:
		seccost = int(ceil(rem / 6)) * 15
	elif rem == 7 or rem == 8:
		seccost = 20
	else:
		seccost = 25
	return firstcost + seccost
T = int(input())
while T > 0:
	n = int(input())
	print(findans(n))
	T -= 1


import sys
input = sys.stdin.readline
tc = int(input())
for _ in range(tc):
	answer = 0
	n = int(input())
	(rhq, remain) = (n // 6, n % 6)
	if rhq == 0:
		answer = 15
	else:
		answer = 15 * rhq
		if 0 < remain <= 2:
			answer += 5
		elif 2 < remain <= 4:
			answer += 10
		elif 4 < remain:
			answer += 15
	print(answer)


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	n = int(input())
	a = n % 8
	b = n // 8 * 20
	if a == 0:
		pass
	elif a <= 2:
		b += 5
	elif a <= 4:
		b += 10
	elif a <= 6:
		b += 15
	else:
		b += 20
	if n <= 6:
		b = 15
	elif n <= 8:
		b = 20
	elif n <= 10:
		b = 25
	print(b)


t = int(input())
from math import floor
for _ in range(t):
	n = int(input())
	print(max(15, (n + 1) // 2 * 5))


import sys
import math
import heapq
from collections import defaultdict as dd
from collections import OrderedDict as od
from collections import deque
from itertools import permutations as pp
from itertools import combinations as cc
from sys import stdin
from functools import cmp_to_key
from functools import lru_cache
from bisect import bisect_left as bs_l
from bisect import bisect_right as bs_r
input = sys.stdin.readline
mod = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 5)
T = int(input())
(pa, pb, pc) = (6, 8, 10)
(ta, tb, tc) = (15, 20, 25)
for _ in range(T):
	n = int(input())
	if n <= 6:
		print(15)
	elif n % 2 == 0:
		print(n // 2 * 5)
	else:
		print((n // 2 + 1) * 5)


from collections import defaultdict
import math

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

def gcd(n, m):
	return math.gcd(n, m)

def foo(n, d, c):
	div = n // d
	if n % d == 0:
		return c * div
	return c * (div + 1)
t = int(input())
for t1 in range(0, t):
	n = int(input())
	ans = max(6, n + 1) // 2 * 5
	print(ans)


w = int(input())
l = []
for i in range(w):
	k = int(input())
	l.append(k)
for i in l:
	if i <= 6:
		print(15)
	elif i == 7 or i == 8:
		print(20)
	else:
		a = (i - 7) // 2
		print((a + 4) * 5)


t = int(input())
otv = list()
for i in range(t):
	n = int(input())
	if n <= 6:
		otv.append(15)
	else:
		otv.append((n + 1) // 2 * 5)
for i in otv:
	print(i)


T = int(input())
for i in range(T):
	j = int(input())
	if j <= 6:
		print(15)
	else:
		print(int((j + j % 2) // 2 * 5))


import sys
import math
import random
from queue import PriorityQueue as PQ
from bisect import bisect_left as BSL
from bisect import bisect_right as BSR
from collections import OrderedDict as OD
from collections import Counter
from itertools import permutations
mod = 1000000007
try:
	sys.stdin = open('actext.txt', 'r')
	OPENFILE = 1
except:
	pass

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

def palindrome(s):
	mid = len(s) // 2
	for i in range(mid):
		if s[i] != s[len(s) - i - 1]:
			return False
	return True

def check(i, n):
	if 0 <= i < n:
		return True
	else:
		return False
t = int(input())
for tt in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	else:
		if n % 2 != 0:
			n += 1
		time = (n // 6 - 1) * 15
		n = n % 6 + 6
		if n == 10:
			time += 25
		elif n == 8:
			time += 20
		else:
			time += 15
		print(time)


from __future__ import division, print_function
import math
import os, 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

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

def si():
	return input()

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

def msi():
	return map(str, input().strip().split(' '))

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

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
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
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

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

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 ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

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

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

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i ** 2 <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i += 6
	return True

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	for _ in range(ii()):
		n = ii()
		if n <= 6:
			print(15)
			continue
		if n % 2 != 0:
			n += 1
		one = 5 / 2
		print(n // 2 * 5)
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin
from collections import defaultdict
from math import ceil
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	if n <= 6:
		print(15)
	else:
		if n % 2:
			n += 1
		print(n // 2 * 5)


t = int(input())
while t:
	t -= 1
	n = int(input())
	print(max(15, 5 * (n // 2 + min(1, n % 2))))


n = int(input())
l = []
for i in range(n):
	t = int(input())
	l.insert(i, t)
for i in l:
	m = int(i / 2)
	k = i * 2
	t = m + k
	if t <= 15:
		print(15)
	elif t % 5 == 0:
		print(t)
	else:
		x = 5 - t % 5
		t = t + x
		print(t)


import sys
input_file = sys.stdin
output_file = sys.stdout
for i in range(int(input_file.readline())):
	n = int(input_file.readline())
	if n % 2 == 1:
		n += 1
	output_file.write(str(max(n, 6) // 2 * 5) + '\n')


t = int(input())
for u in range(t):
	n = int(input())
	if n % 2 == 1:
		n += 1
	r = n % 10
	if r == 0:
		print(n // 10 * 25)
	elif r == 6:
		print(n // 10 * 25 + 15)
	elif r == 8:
		print(n // 10 * 25 + 20)
	elif r == 2:
		if n == 2:
			print(15)
		else:
			print((n // 10 - 1) * 25 + 30)
	elif r == 4:
		if n == 4:
			print(15)
		else:
			print((n // 10 - 1) * 25 + 35)


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	if n % 2 == 1:
		n += 1
	n //= 2
	if n % 5 == 0:
		print(n * 25 // 5)
	elif n % 5 == 1:
		if n == 1:
			print(15)
		else:
			print((n - 6) * 25 // 5 + 15 + 15)
	elif n % 5 == 2:
		if n == 2:
			print(15)
		else:
			print((n - 7) * 25 // 5 + 15 + 20)
	else:
		print(n * 5)
for i in range(int(input())):
	solve()


t = int(input())
n = []
for i in range(t):
	ni = int(input())
	n.append(ni)
for i in n:
	r = i % 6
	a = i // 6
	if i <= 6:
		s = 15
	elif r == 0:
		s = a * 15
	elif r != 0 and r <= 2:
		s = a * 15 + 5
	elif r != 0 and r <= 4:
		s = a * 15 + 10
	else:
		s = (a + 1) * 15
	print(s)


import sys
import math
import collections
from os import path
from collections import defaultdict
mod = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 6)
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
test = int(sys.stdin.readline().rstrip())
while test > 0:
	test -= 1
	n = int(sys.stdin.readline().rstrip())
	ans = 0
	if n < 7:
		ans = 15
	else:
		if n % 2 != 0:
			n += 1
		ans = n * 5 // 2
	print(ans)


import math
num = int(input())
ip = []
for _ in range(num):
	temp = int(input())
	ip.append(temp)

def time(n):
	num6 = math.ceil(n / 6)
	rem6 = n % 6
	num8 = 0
	num10 = 0
	if n > 6:
		if rem6 in [1, 2]:
			num6 = num6 - 2
			num8 = 1
		if rem6 in [3, 4]:
			num6 = num6 - 2
			num10 = 1
	output = num6 * 15 + num8 * 20 + num10 * 25
	return output
for _ in ip:
	print(time(_))


t = int(input())
for z in range(t):
	n = int(input())
	x = n // 6
	y = n % 6
	if x == 0:
		print(15)
	elif y == 0:
		print(15 * x)
	elif y == 1 or y == 2:
		print(15 * x + 5)
	elif y == 3 or y == 4:
		print(15 * x + 10)
	else:
		print(15 * x + 15)


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

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

def imi():
	return map(int, input().split())
t = ii()
for _ in range(t):
	n = ii()
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	elif n % 2 == 0:
		print(5 * n // 2)
	else:
		print(5 * (n + 1) // 2)


import sys, math, bisect
sys.setrecursionlimit(10 ** 4)
from random import randint
inf = float('inf')
mod = 10 ** 9 + 7

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

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

def tobinary(n):
	return bin(n)[2:]

def binarySearch(a, x):
	i = bisect.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	else:
		return -1

def lowerBound(a, x):
	i = bisect.bisect_left(a, x)
	if i:
		return i - 1
	else:
		return -1

def upperBound(a, x):
	i = bisect.bisect_right(a, x)
	if i != len(a) + 1 and a[i - 1] == x:
		return i - 1
	else:
		return -1

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

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

def isPrime(n, k=5):
	if n < 2:
		return True
	for i in range(0, k):
		a = randint(1, n - 1)
		if pow(a, n - 1, n) != 1:
			return False
	return True
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop, heapify
import string
for _ in range(int(input())):
	n = int(input())
	print(max(6, n + 1) // 2 * 5)


T = int(input())
for _ in range(T):
	n = int(input())
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	else:
		if n & 1:
			n += 1
		print(n // 2 * 5)


import os
import math
import sys
from collections import Counter
parse_input = lambda : sys.stdin.readline().rstrip('\r\n')

def func(n):
	if n <= 6:
		return 15
	if 6 < n <= 8:
		return 20
	if 8 < n <= 10:
		return 25
	if n % 6 == 0:
		return int(n // 6 * 15)
	elif n % 6 == 5:
		return int((n // 6 + 1) * 15)
	elif n % 6 == 4 or n % 6 == 3:
		return int((n // 6 - 1) * 15 + 25)
	elif n % 6 == 2 or n % 6 == 1:
		return int((n // 6 - 1) * 15 + 20)

def main():
	n_cases = int(parse_input())
	for i in range(n_cases):
		n = int(parse_input())
		print(func(n))
main()


def main(N):
	if N <= 6:
		return 15
	elif N <= 8:
		return 20
	elif N <= 10:
		return 25
	else:
		(small, medium, large) = (0, 0, 0)
		large = N // 10
		if 0 < N % 10 <= 2:
			large -= 1
			small += 2
		elif 2 < N % 10 <= 4:
			large -= 1
			small += 1
			medium += 1
		elif 4 < N % 10 <= 6:
			small += 1
		elif 6 < N % 10 <= 8:
			medium += 1
		elif 8 < N % 10 <= 9:
			large += 1
		return small * 15 + medium * 20 + large * 25
t = int(input())
ans = []
for i in range(t):
	N = int(input())
	ans.append(main(N))
for i in ans:
	print(i)


for _ in range(int(input())):
	print(max(15, (int(input()) + 1) // 2 * 5))


import sys
input = sys.stdin.readline
a = int(input())
for _ in range(a):
	t = int(input())
	if t <= 6:
		print(15)
	else:
		print((t + 1) // 2 * 5)


from __future__ import division, print_function
import os, 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
from bisect import bisect_left as lower_bound, bisect_right as upper_bound

def so():
	return int(input())

def st():
	return input()

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

def msj():
	return map(str, input().strip().split(' '))

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

def lebe():
	return list(map(int, input()))

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()

def joro(L):
	return ''.join(map(str, L))

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

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

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def tr(n):
	return n * (n + 1) // 2

def iu():
	import sys
	m = so()
	if m % 2 == 1:
		m = m // 2 + 1
	else:
		m = m // 2
	if m <= 3:
		print(15)
	else:
		print(5 * m)

def main():
	for i in range(so()):
		iu()
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
l = []
for i in range(t):
	n = int(input())
	val = 0
	if n < 7:
		val = 15
	elif n < 9:
		val = 20
	elif n < 11:
		val = 25
	elif n % 10 == 0:
		val = n // 10 * 25
	else:
		r = n % 10
		val = n // 10 * 25
		if r == 9:
			val = val + 25
		elif r == 7 or r == 8:
			val = val + 20
		elif r == 5 or r == 6:
			val = val + 15
		elif r == 3 or r == 4:
			val = val + 10
		else:
			val = val + 5
	l.append(val)
for i in l:
	print(i)


T = int(input())
ans = []
for test in range(T):
	n = int(input())
	if n < 6:
		case = 15
	else:
		val1 = (n - 1) // 2
		case = 5 + val1 * 5
	ans.append(case)
for t in ans:
	print(t)


T = int(input())
for t in range(T):
	n = int(input())
	if n % 2 == 1:
		n += 1
	if n <= 6:
		print(15)
		continue
	print(n // 2 * 5)


import sys
input = sys.stdin.readline

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

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

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

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

def main():
	T = inp()
	while T > 0:
		n = inp()
		if n <= 6:
			print(15)
			T -= 1
			continue
		ans = (n // 6 - 1) * 15
		n = 6 + n % 6
		if n == 6:
			ans += 15
		elif n <= 8:
			ans += 20
		elif n <= 10:
			ans += 25
		else:
			ans += 30
		print(ans)
		T -= 1
main()


num_of_orders = int(input())
list_of_orders = []
for order in range(num_of_orders):
	list_of_orders.append(int(input()))
for order in list_of_orders:
	time = 0
	if 0 < order <= 6:
		time = 15
	if 6 < order <= 8:
		time = 20
	if 8 < order <= 10:
		time = 25
	if order >= 10:
		if order % 2 == 1:
			order += 1
		time = order * 5 // 2
	print(time)


t = int(input())
ch = ''
for i in range(t):
	n = int(input())
	if n <= 6:
		res = 15
	elif n == 7 or n == 8:
		res = 20
	elif n < 10:
		res = 25
	elif n % 10 == 0:
		res = n // 10 * 25
	elif n % 8 == 0:
		res = n // 8 * 20
	elif n % 6 == 0:
		res = n // 6 * 15
	elif n % 10 > 0:
		mod = n % 10
		if mod <= 2:
			res = (n // 10 - 1) * 25 + 15 + 15
		elif mod <= 4:
			res = (n // 10 - 1) * 25 + 15 + 20
		elif mod <= 6:
			res = n // 10 * 25 + 15
		elif mod <= 8:
			res = n // 10 * 25 + 20
		else:
			res = n // 10 * 25 + 25
	if i == t - 1:
		ch += str(res)
	else:
		ch += str(res) + '\n'
print(ch)


for tests in range(int(input())):
	n = int(input())
	ans = 0
	if n % 2 == 0:
		if n <= 6:
			ans = 15
		else:
			ans = n // 2
			ans *= 5
	elif n <= 6:
		ans = 15
	else:
		ans = min(5 * ((n + 1) // 2), 15 + 5 * ((n - 1) // 2))
	print(ans)


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	if n <= 6:
		sys.stdout.write('15\n')
	else:
		sys.stdout.write('%d\n' % ((n + n % 2) * 5 // 2))


t = int(input())
for i in range(t):
	n = int(input())
	print(max(15, (n + n % 2) * 5 // 2))


import math

def solve():
	n = int(input())
	if n <= 6:
		print(15)
		return
	ans = n // 6 * 15
	n %= 6
	if n <= 0:
		ans += 0
	elif n <= 2:
		ans += 5
	elif n <= 4:
		ans += 10
	else:
		ans += 15
	print(ans)
t = int(input())
while t > 0:
	solve()
	t -= 1


n = int(input())
result = []
for i in range(n):
	x = int(input())
	if x % 2 == 1:
		x += 1
	time = round(5 * x // 2)
	if time < 15:
		time = 15
	result.append(time)
for i in result:
	print(i)


t = int(input())
arr = [0, 30, 30, 35, 35, 40, 40, 45, 45, 50, 50]
for i in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	else:
		a = int(n / 10) - 1
		b = n % 10
		if b == 0:
			a = a + 1
			print(a * 25)
		else:
			print(a * 25 + arr[b])


t = int(input())
for i in range(t):
	n = int(input())
	x = y = 0
	x = int(n / 6)
	y = n % 6
	if n <= 6:
		print('15')
	elif y == 0:
		s = x * 15
		print(s)
	elif y <= 2:
		s = x * 15 + 5
		print(s)
	elif y <= 4:
		s = x * 15 + 10
		print(s)
	else:
		x = x + 1
		s = x * 15
		print(s)


t = int(input())
for k in range(t):
	n = int(input())
	print(max(15, (n + 1) // 2 * 5))


import sys, math
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	if n <= 6:
		print(15)
	elif n <= 8:
		print(20)
	elif n <= 10:
		print(25)
	elif n % 2 == 0:
		print(5 * n // 2)
	else:
		print(5 * (n + 1) // 2)


for raifb in range(int(input())):
	n = int(input())
	if n % 2:
		n += 1
	n //= 2
	if n <= 3:
		print(15)
	else:
		print(n * 5)


t = int(input())
for _ in range(t):
	n = int(input())
	if n <= 6:
		print(15)
	else:
		k = n // 2
		if n % 2:
			k += 1
		print(5 * k)


n = int(input())
a = []
for p in range(n):
	a.append(int(input()))
for q in range(n):
	if a[q] <= 6:
		print(15)
	elif a[q] % 2 == 0:
		print(int(a[q] // 2 * 5))
	else:
		print(int((a[q] + 1) // 2 * 5))


t = int(input())
while t:
	n = int(input())
	print(max(6, n + 1) // 2 * 5)
	t -= 1


import math
for _ in range(int(input())):
	n = int(input())
	k = n % 10
	if n <= 6:
		print(15)
	elif k == 0 or k == 9:
		print(25 * math.ceil(n / 10))
	elif k == 7 or k == 8:
		if k == 7:
			n += 1
		print(20 + 25 * (n - 8) // 10)
	elif k == 5 or k == 6:
		if k == 5:
			n += 1
		print(15 + 25 * (n - 6) // 10)
	elif k == 3 or k == 4:
		if k == 3:
			n += 1
		print(35 + 25 * (n - 14) // 10)
	else:
		if k == 1:
			n += 1
		print(30 + 25 * (n - 12) // 10)


t = int(input())
ans = []
for i in range(t):
	x = int(input())
	if x < 6:
		ans.append(15)
	elif x >= 6 and x % 2 == 0:
		ans.append(x * 5 // 2)
	elif x >= 6 and x % 2 == 1:
		ans.append((x - 1) * 5 // 2 + 5)
print(*ans, sep='\n')


import sys

def minimumMinute(a):
	if a < 6:
		return 15
	if a % 2 == 1:
		return minimumMinute(a + 1)
	if a % 6 == 0:
		return int(a / 6) * 15
	if a % 6 == 2:
		return int((a - 2) / 6 - 1) * 15 + 20
	if a % 6 == 4:
		return int((a - 4) / 6 - 1) * 15 + 25
n = int(sys.stdin.readline())
cases = [0] * n
for i in range(0, n):
	cases[i] = int(sys.stdin.readline())
for i in range(0, n):
	print(minimumMinute(cases[i]))


import sys

def rall():
	return sys.stdin.readlines()

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

def rl_types(types):
	str_list = [x for x in sys.stdin.readline().strip().split(' ')]
	return [types[i](str_list[i]) for i in range(len(str_list))]

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

def pra(array):
	sys.stdout.write(' '.join([str(x) for x in array]) + '\n')

def solve(array):
	return array
NT = int(rl())
(NS, NM, NL) = (6, 8, 10)
(TS, TM, TL) = (15, 20, 25)
for ti in range(NT):
	n = int(rl())
	if n % 2 == 1:
		n += 1
	nl = n // NL
	nr = n - nl * NL
	if nr in [NS, NM]:
		t = n // 2 * 5
	elif nl == 0:
		t = TS
	else:
		t = n // 2 * 5
	pr(t)


casos = int(input())
cont = 0
while cont != casos:
	cont += 1
	numero = int(input())
	x1 = numero // 10
	tiempo1 = 0
	if x1 * 10 == numero:
		tiempo1 = x1 * 25
	elif numero < 7 and x1 == 0:
		tiempo1 = 15
	elif numero < 9 and numero > 6 and (x1 == 0):
		tiempo1 = 20
	elif numero == 9 and x1 == 0:
		tiempo1 = 25
	elif numero - x1 * 10 < 3:
		tiempo1 = (x1 - 1) * 25 + 2 * 15
	elif numero - x1 * 10 > 2 and numero - x1 * 10 < 5:
		tiempo1 = (x1 - 1) * 25 + 15 + 20
	elif numero - x1 * 10 > 4 and numero - x1 * 10 < 7:
		tiempo1 = (x1 - 1) * 25 + 20 * 2
	elif numero - x1 * 10 > 6 and numero - x1 * 10 < 9:
		tiempo1 = x1 * 25 + 20
	elif numero - x1 * 10 == 9:
		tiempo1 = (x1 + 1) * 25
	print(int(tiempo1))


import sys
import math
from collections import Counter
input = sys.stdin.readline
N = 1000000007
for i in range(int(input().strip())):
	s = int(input().strip())
	ans = 5 * ((s + 1) // 2)
	if s < 6:
		print(15)
	else:
		print(ans)


t = int(input())
while t > 0:
	print(max(15, (int(input()) + 1) // 2 * 5))
	t -= 1


t = int(input())
for _ in range(t):
	n = int(input())
	if n % 2 == 0 and n > 5:
		print(5 * n // 2)
	elif n <= 5:
		print(15)
	else:
		print(5 * (n + 1) // 2)