Mishka got a six-faced dice. It has integer numbers from $2$ to $7$ written on its faces (all numbers on faces are different, so this is an almost usual dice).

Mishka wants to get exactly $x$ points by rolling his dice. The number of points is just a sum of numbers written at the topmost face of the dice for all the rolls Mishka makes.

Mishka doesn't really care about the number of rolls, so he just wants to know any number of rolls he can make to be able to get exactly $x$ points for them. Mishka is very lucky, so if the probability to get $x$ points with chosen number of rolls is non-zero, he will be able to roll the dice in such a way. Your task is to print this number. It is guaranteed that at least one answer exists.

Mishka is also very curious about different number of points to score so you have to answer $t$ independent queries.


-----Input-----

The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of queries.

Each of the next $t$ lines contains one integer each. The $i$-th line contains one integer $x_i$ ($2 \le x_i \le 100$) — the number of points Mishka wants to get.


-----Output-----

Print $t$ lines. In the $i$-th line print the answer to the $i$-th query (i.e. any number of rolls Mishka can make to be able to get exactly $x_i$ points for them). It is guaranteed that at least one answer exists.


-----Example-----
Input
4
2
13
37
100

Output
1
3
8
27


-----Note-----

In the first query Mishka can roll a dice once and get $2$ points.

In the second query Mishka can roll a dice $3$ times and get points $5$, $5$ and $3$ (for example).

In the third query Mishka can roll a dice $8$ times and get $5$ points $7$ times and $2$ points with the remaining roll.

In the fourth query Mishka can roll a dice $27$ times and get $2$ points $11$ times, $3$ points $6$ times and $6$ points $10$ times.

Difficulty: EASY
Tags: Mathematics

Starter code:

Solutions:
def solve(x):
	total = 0
	total += x // 2
	return total
t = int(input())
for _ in range(t):
	x = int(input())
	print(solve(x))


t = int(input())
for _ in range(t):
	a = int(input())
	print(a // 2)


for u in range(int(input())):
	x = int(input())
	if x % 7 == 0:
		print(x // 7)
	else:
		print(x // 7 + 1)


for i in range(int(input())):
	a = int(input())
	e = a // 2
	if a % 2 == 0:
		print(e)
	else:
		o = e * 2 - 2 + 3
		print(e)


q = int(input())
for i in range(q):
	s = 0
	a = int(input())
	if a < 8:
		print(1)
	else:
		s += a // 7
		if a % 7 > 0:
			s += 1
		print(s)


t = int(input())
while t > 0:
	t -= 1
	x = int(input())
	print(x // 2)


def answer():
	n = int(input())
	while n:
		a = int(input())
		print(int(a / 2))
		n -= 1
answer()


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

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

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

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

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

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

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

def S():
	return input()

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

def main():
	n = I()
	a = [I() for _ in range(n)]
	r = []
	for c in a:
		r.append(c // 2)
	return '\n'.join(map(str, r))
print(main())


diecs = [2, 3, 4, 5, 6, 7]
q = input()
q = int(q)
i = 1
i = int(i)
while i <= q:
	val = input()
	val = int(val)
	if val in diecs:
		print('1')
	elif val not in diecs:
		if val % 2 == 0:
			print(val // 2)
		else:
			val = val - 3
			print(val // 2 + 1)
	i = i + 1


n = int(input())
hasil = []
for i in range(n):
	a = int(input())
	hasil += [a // 2]
for i in hasil:
	print(i)


numQueries = int(input())
queries = []
for i in range(numQueries):
	queries.append(int(input()))
results = []
for query in queries:
	if query == 1:
		dieCount = 0
	elif query % 2 == 1:
		dieCount = (query - 3) // 2 + 1
	else:
		dieCount = query // 2
	results.append(dieCount)
for result in results:
	print(result)


import math, sys

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

def main():
	n = int(input())
	for i in range(n):
		x = int(input())
		print(x // 2)
deb = 0
if deb:
	file = open('input.txt', 'w')
else:
	input = sys.stdin.readline
main()


import math
b = int(input())
for i in range(b):
	n = int(input())
	print(int(math.ceil(n / 7)))


n = int(input())
for _ in range(n):
	x = int(input())
	print(x // 2)


n = int(input())
for i in range(n):
	n1 = int(input())
	print(int(n1 // 2))


t = int(input())
for i in range(t):
	x = int(input())
	if x <= 7:
		print(1)
	else:
		print(x // 6 + 1)


from math import ceil
n = int(input())
for i in range(n):
	x = int(input())
	if x <= 7:
		print(1)
	else:
		print(ceil(x / 7))


n = int(input())
for i in range(0, n):
	x = int(input())
	k = 0
	while x != 0:
		if x >= 7:
			x = x - 7
			k += 1
		elif x < 7:
			k += 1
			break
	print(k)


t = int(input())
for q in range(t):
	n = int(input())
	print(n // 2)


n = int(input())
li = []
i = 0
while i < n:
	i += 1
	k = int(input())
	li = li + [k]
for i in li:
	no = i // 7
	print(no + 1)


for _ in range(int(input())):
	x = int(input())
	res = 0
	if x & 1:
		x -= 3
		res += 1
	res += x // 2
	print(res)


for _ in range(int(input())):
	c = 0
	n = int(input())
	while n > 7:
		n = n - 7
		c += 1
	print(c + 1)


for _ in range(int(input())):
	x = int(input())
	if x <= 7 and x >= 2:
		print(1)
	elif x % 2 == 0:
		print(x // 2)
	else:
		x -= 3
		print(x // 2 + 1)


q = int(input())
for i in range(q):
	num = int(input())
	if num % 2:
		print(1 + (num - 3) // 2)
	else:
		print(num // 2)


t = int(input())
for i in range(t):
	n = int(input())
	print(n // 2)


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 = True
testingMode = False
optimiseForReccursion = False

def main():
	n = get_int()
	print(math.floor(n / 2))
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()


a = int(input())
x = 0
for i in range(a):
	br = int(input())
	if x >= 2 and x <= 7:
		print(1)
	elif br % 7 == 0:
		print(int(br / 7))
	else:
		print(int(br / 7) + 1)


import math

def rolls_count(score):
	count = score // 7
	left = score % 7
	if left != 0:
		count += 1
	return count
n = int(input())
for _ in range(n):
	score = int(input())
	print(rolls_count(score))


def shrey():
	n = input()
	n = int(n)
	print(n // 2)
T = int(input())
for _ in range(1, T + 1):
	shrey()


for _ in range(int(input())):
	n = int(input())
	if n % 7 == 0:
		print(n // 7)
	else:
		print(n // 7 + 1)


total_query = int(input())
query = []
for i in range(total_query):
	a = int(input())
	query.append(a)
for j in range(total_query):
	if query[j] <= 7:
		print(1)
	else:
		a = query[j] // 7
		print(a + 1)


n = int(input())
for i in range(n):
	d = int(input())
	print(d // 2)


c = []
y = int(input(''))
for i in range(y):
	x = int(input(''))
	d = x / 2
	d = int(d)
	c.append(d)
for i in c:
	print(i)


no = int(input())
res = []
for i in range(no):
	num = int(input())
	main = num // 2
	res.append(main)
for i in res:
	print(i)


def rolling(n, ls):
	l = []
	for i in range(n):
		c = 0
		s = 7
		while ls[i] > 0:
			if ls[i] > 1 and ls[i] < 8:
				c = c + 1
				ls[i] = 0
			elif ls[i] % s != 1:
				c = c + int(ls[i] / s)
				ls[i] = ls[i] % s
			s = s - 1
		l.append(c)
	return l
n = int(input())
ls = [int(input()) for i in range(n)]
print('\n'.join(map(str, rolling(n, ls))))


import math
n = int(input())
for _ in range(n):
	x = int(input())
	print(math.ceil(x / 7))


n = int(input())
for k in range(n):
	c = int(input())
	cont = 0
	while c > 0:
		cont += 1
		c -= 7
	print(cont)


def fon(n):
	c = 0
	while c < n:
		if n % 2 == 0 or n % 2 > 1:
			c += n // 2
			n = n % 2
		else:
			c += n // 3
			n = n % 3
	return c
e = int(input())
d = []
for i in range(e):
	a = int(input())
	d.append(fon(a))
for i in d:
	print(i)


n = int(input())
for i in range(n):
	x = int(input())
	print(int(x / 2))


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')
for _testcases_ in range(int(input())):
	print(int(input()) // 2)


n = int(input())
a = []
k = 0
for i in range(n):
	b = int(input())
	a.append(b)
for i in range(n):
	if a[i] < 8:
		print(1)
	else:
		k = a[i] / 7
		k = int(k) + 1
		print(k)


def calculate(value):
	if value <= 1:
		return 0
	total_nos = value // 7
	mod = value % 7
	if mod >= 1:
		total_nos += 1
	return total_nos
nos_queries = int(input())
for _ in range(0, nos_queries):
	print('{:d}'.format(calculate(int(input()))))


n = int(input())
for i in range(n):
	print(int(input()) // 4 + 1)


i = int(input())
for _ in range(i):
	o = int(input())
	if o < 3:
		print(o // 2)
	else:
		print(o // 3)


for i in range(int(input())):
	i = int(input())
	print(i // 7 + int(bool(i % 7)))


from random import randint

def dado(num):
	lancamentos = 0
	while True:
		if num % 2 == 0:
			while True:
				num -= 2
				lancamentos += 1
				if num == 0:
					return lancamentos
		if num % 3 == 0:
			while True:
				num -= 3
				lancamentos += 1
				if num == 0:
					return lancamentos
		if num % 5 == 0:
			while True:
				num -= 5
				lancamentos += 1
				if num == 0:
					return lancamentos
		if num % 7 == 0:
			while True:
				num -= 7
				lancamentos += 1
				if num == 0:
					return lancamentos
		else:
			lancamento = randint(2, 7)
			if num - lancamento != 1:
				num -= lancamento
				lancamentos += 1
queries = int(input())
for __ in range(queries):
	num = int(input())
	print(dado(num))


t = int(input())
while t > 0:
	n = int(input())
	if n % 7 == 0:
		print(n // 7)
	elif n % 6 == 0:
		print(n // 6)
	elif n % 5 == 0:
		print(n // 5)
	elif n % 4 == 0:
		print(n // 4)
	elif n % 3 == 0:
		print(n // 3)
	elif n % 2 == 0:
		print(n // 2)
	elif n % 2 in [3, 5, 7]:
		print(n // 2 + 1)
	elif n % 3 in [2, 4, 5, 7]:
		print(n // 3 + 1)
	elif n % 4 in [2, 3, 6, 5, 7]:
		print(n // 3 + 1)
	elif n % 5 in [2, 3, 4, 6, 7]:
		print(n // 5 + 1)
	elif n % 6 in [2, 3, 4, 5, 7]:
		print(n // 3 + 1)
	elif n % 7 in [2, 3, 4, 5, 6]:
		print(n // 7 + 1)
	t -= 1


que = int(input())
while que != 0:
	que -= 1
	x = int(input())
	if x / 7 == x // 7:
		print(x // 7)
	else:
		print(x // 7 + 1)
	if que == 0:
		break


t = int(input())
for i in range(t):
	n = int(input())
	if n <= 7:
		print('1')
	else:
		r = int(n / 7)
		rem = n % 7
		if rem == 0:
			print(r)
		else:
			print(r + 1)


def three_numbers():
	numbers = list(map(int, input().split(sep=' ')))
	m = max(numbers)
	for i in numbers:
		if i != m:
			print(m - i, end=' ')

def gen_and_card_game():
	card = input()
	my_cards = list(input().split(sep=' '))
	for i in my_cards:
		if i[0] == card[0] or i[1] == card[1]:
			print('YES')
			break
	else:
		print('NO')

def kazak_vus_and_contest():
	(a, b, c) = map(int, input().split(sep=' '))
	if a - b <= 0 and a - c <= 0:
		print('YES')
	else:
		print('NO')

def like_A():
	st = input()
	count_a = 0
	for i in st:
		if i == 'a':
			count_a += 1
	if count_a > len(st) - count_a:
		print(len(st))
	else:
		print(count_a + count_a - 1)

def three_piece_candies():
	n = int(input())
	for i in range(n):
		(a, b, c) = map(int, input().split(sep=' '))
		print((a + b + c) // 2)

def re_encryption():
	n = int(input())
	encryption = input()
	decipherment = ''
	k = 0
	while 0 != n:
		k += 1
		n -= k
	for i in range(1, k + 1):
		decipherment += encryption[0]
		encryption = encryption[i:]
	print(decipherment)

def two_type_burgers():
	n = int(input())
	for i in range(n):
		(a, b, c) = map(int, input().split(sep=' '))
		(p_b, p_c) = map(int, input().split(sep=' '))
		sum = 0
		if p_b > p_c:
			if a - b * 2 >= 0:
				a = a - b * 2
				sum += b * p_b
				if a - c * 2 >= 0:
					sum += c * p_c
				else:
					sum += a // 2 * p_c
			else:
				sum += a // 2 * p_b
		elif a - c * 2 >= 0:
			a = a - c * 2
			sum += c * p_c
			if a - b * 2 >= 0:
				sum += b * p_b
			else:
				sum += a // 2 * p_b
		else:
			sum += a // 2 * p_c
		print(sum)

def throw_cub():
	n = int(input())
	for i in range(n):
		k = int(input())
		if k % 7 == 1:
			count = k // 7 + 1
		else:
			count = k // 7 + (k % 7 > 0)
		print(count)
throw_cub()


try:
	for _ in range(int(input())):
		n = int(input())
		print(n // 2)
except:
	pass


t = int(input())
while t:
	k = int(input())
	ans = 0
	ans = k // 7 + 1
	print(ans)
	t -= 1


a = int(input())
for x in range(a):
	y = int(input())
	if y % 6 == 0:
		print(int(y / 6))
	else:
		print(int(y / 6) + 1)


t = int(input())
ch = ''
for i in range(t):
	s = 0
	x = int(input())
	ch += str(x // 2) + '\n'
print(ch)


t = int(input())
for _ in range(t):
	n = int(input())
	a = [7, 6, 5, 4, 3, 2]
	x = 0
	i = 0
	while i < 6 and n > 0:
		if n < a[i]:
			i += 1
		else:
			c = n % a[i]
			x += n // a[i]
			n = c
	if n == 1:
		x += 1
	print(x)


def func(x):
	arr = [2, 3, 4, 5, 6, 7]
	for y in arr:
		if x % y == 0:
			print(x // y)
			break
		elif x % y in arr:
			print(x // y + 1)
			break

def main():
	n = int(input())
	for _ in range(n):
		func(int(input()))
main()


case = int(input())
for i in range(case):
	score = int(input())
	if score <= 7:
		print(1)
	else:
		print(score // 7 + 1)


def ans(n):
	cnt = n // 7 + 1
	return cnt
t = int(input())
for _ in range(t):
	n = int(input())
	print(ans(n))


exec(int(input()) * 'print(int(input())//2);')


def get(x):
	if x <= 7:
		return 1
	for i in range(0, 100):
		rest = x - 2 * i
		if rest < 0 or rest % 3 != 0:
			continue
		return i + rest // 3
for _ in range(int(input())):
	x = int(input())
	print(get(x))


t = int(input())
for i in range(t):
	x = int(input())
	for j in range(2, 8):
		if x % j != 1:
			print(x // j + (x % j > 0))
			break


t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	print((n + 6) // 7)


import math
import queue
t = int(input())
for i in range(0, t):
	x = int(input())
	answer = x // 2
	print(answer)


from math import ceil
t = int(input())
a = []
for i in range(t):
	a.append(int(input()))

def chk(k):
	return ceil(k / 7)
for i in a:
	print(chk(i))


import random as R
import math
list1 = []
a = int(input(''))
for i in range(0, a):
	b = int(input(''))
	num = b / 7
	list1.append(math.ceil(num))
print(' '.join((str(i) for i in list1)))


x = int(input())
for x in range(x):
	y = int(input(''))
	if y >= 2 and y <= 7:
		print('1')
	elif y / 7 == 0:
		print(int(y / 77))
	else:
		print(int(y // 7) + 1)


A = []
for i in range(int(input())):
	q = int(input())
	A.append(q // 2)
for a in A:
	print(a)


a = int(input())
n = 0
z = []
while a > 0:
	b = int(input())
	if b % 2 == 0:
		while b > 0:
			b -= 2
			n += 1
	else:
		b -= 1
		while b > 0:
			b -= 2
			n += 1
	a -= 1
	z += [n]
	n = 0
for i in range(len(z)):
	print(z[i])


n = int(input())
for i in range(n):
	a = int(input())
	if a % 7 == 0:
		print(a // 7)
	else:
		print(a // 7 + 1)


for i in range(int(input())):
	n = int(input())
	if n == 2 or n == 3:
		print(1)
	elif n > 3 and n <= 14:
		print(2)
	else:
		print(n // 7 + 1)


N = int(input())
for i in range(0, N):
	X = int(input())
	for j in range(2, 8):
		if X % j == 0:
			print(X // j)
			break
		elif 2 <= X % j and X % j <= 7:
			print(X // j + 1)
			break


t = int(input())
for i in range(t):
	n = int(input())
	if n % 7 != 1:
		print(n // 7 + 1)
	elif n == 1:
		print(1)
	elif n == 15 or n == 85:
		print(n // 5)
	elif n == 57 or n == 99:
		print(n // 3)
	elif n % 2 == 0:
		print(n // 2)
	elif n == 29:
		print(n // 6 + 1)
	else:
		print(n // 4 + 1)


import sys
import math
import bisect

def main():
	for _ in range(int(input())):
		n = int(input())
		ans = 0
		while n:
			if n == 3:
				n -= 3
				ans += 1
			else:
				n -= 2
				ans += 1
		print(ans)
main()


import math
import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	for i in range(2, 8):
		if n % i != 1:
			print(n // i) if n % i == 0 else print(n // i + 1)
			break


t = int(input())
for i in range(t):
	n = int(input())
	if n % 2 == 0:
		print(int(n / 2))
	else:
		print(int((n - 3) / 2) + 1)


t = int(input())
s = 0
for i in range(t):
	x = int(input())
	s = x // 2
	print(s)


n = int(input())
for i in range(n):
	x = int(input())
	if x < 7:
		print(1)
	elif x % 7 == 0:
		print(x // 7)
	else:
		print(x // 7 + 1)


import sys
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda : list(map(int, input().strip().split()))

def main():
	for _ in range(int(input())):
		n = int(input())
		print(n // 7 + (n % 7 != 0))
main()


a = int(input())
b = 0
for i in range(a):
	b = int(input())
	print((b + 6) // 7)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	if n < 3:
		print('1')
	else:
		print(n // 3)


import math
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	l = int(math.ceil(n / 7))
	r = int(math.floor(n / 2))
	print(r)


for _ in range(int(input())):
	print(int(input()) // 2)


t = int(input())
l = []
for i in range(t):
	n = int(input())
	print(n // 7 + 1)


def main():
	n_queries = int(input())
	for _ in range(n_queries):
		print(int(input()) // 2)
main()


t = int(input())
a = []
for i in range(t):
	b = int(input())
	a.append(b)
for i in range(0, t):
	k = 0
	while a[i] > 0:
		if a[i] >= 7:
			a[i] -= 7
			k += 1
		if a[i] == 6:
			a[i] -= 6
			k += 1
		if a[i] == 5:
			a[i] -= 5
			k += 1
		if a[i] == 4:
			a[i] -= 4
			k += 1
		if a[i] == 3:
			a[i] -= 3
			k += 1
		if a[i] == 2:
			a[i] -= 2
			k += 1
		if a[i] == 1:
			a[i] -= 1
			k += 1
	print(k)


t = int(input())
for i in range(t):
	x = int(input())
	r = x // 7
	if x % 7 == 0:
		print(x // 7)
	else:
		print(x // 7 + 1)


n = int(input())
for x in range(n):
	e = int(input())
	print(e // 2)


from math import *
t = int(input())
ansarr = []
for l in range(t):
	n = int(input())
	if n <= 7:
		ansarr.append(1)
	else:
		ansarr.append(ceil(n / 6))
print(*ansarr)


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
for _ in range(int(f_input())):
	f_print(str(int(f_input()) // 2) + '\n')


import sys
t = int(input())
for x in range(t):
	z = int(input())
	c = 0
	if z % 2 == 1:
		z -= 3
		c += 1
	c += z / 2
	print(int(c))


import math
case = int(input())
for caseNum in range(0, case):
	n = int(input())
	print(math.ceil(n / 7))


n = int(input())
a = list()
for i in range(n):
	score = int(input())
	if score <= 7:
		a.append(1)
		continue
	else:
		k = score / 3
		if score % 3 > 1:
			a.append(int(k))
		else:
			a.append(int(k) + 1)
for e in a:
	print(e)


def read_input():
	n_queries = int(input())
	queries = []
	for _ in range(n_queries):
		queries.append(int(input()))
	return queries

def dice_rolling(query):
	roll_count = 1
	for top_face_of_dice in range(7, 1, -1):
		if query > top_face_of_dice:
			roll_count += query // top_face_of_dice
			query = query - query // top_face_of_dice * top_face_of_dice
		else:
			break
	return roll_count

def print_results(results):
	for result in results:
		print(result)
queries = read_input()
results = []
for query in queries:
	results.append(dice_rolling(query))
print_results(results)


counter = int(input())
given = []
result = []
for i in range(counter):
	a = int(input())
	given.append(a)
for i in given:
	if i <= 7:
		result.append(1)
		continue
	res = 0
	begin = i
	start = 0
	if begin % 2 == 0:
		start = 7
	else:
		start = 6
	while begin != 0:
		if begin >= start:
			begin -= start
			res += 1
		else:
			start -= 1
	result.append(res)
for i in result:
	print(i)


for i in range(int(input())):
	k = int(input())
	print(int(k / 2))


t = int(input())
N = 100
A = [None] * (N + 1)
for i in range(2, 8):
	A[i] = 1
for i in range(8, N + 1):
	A[i] = 1 + A[i - 6]
for i in range(t):
	x = int(input())
	print(A[x])


numQueries = int(input())
for i in range(numQueries):
	num = int(input())
	if num <= 7:
		print(1)
	else:
		print(num // 2)


def solve():
	rd = lambda : list(map(int, input().split()))
	n = int(input())
	for i in range(n):
		x = int(input())
		if x <= 7:
			print(1)
		elif x % 2 == 0:
			print(int(x / 2))
		else:
			cnt = 0
			cnt += int(x / 3)
			if x % 3 == 1:
				cnt -= 1
			cnt += 1
			print(cnt)
solve()


t = int(input())
o = []
min_point_roll = 2
max_point_roll = 7
for _ in range(t):
	points = int(input())
	remainder = points % max_point_roll
	if remainder == 0:
		o.append(points // max_point_roll)
	else:
		o.append(points // max_point_roll + 1)
for l in o:
	print(l)


n = int(input())
for val in range(n):
	points = int(input())
	if int(points / 7) != points / 7:
		print(int(points / 7) + 1)
	else:
		print(int(points / 7))


from sys import stdin, stdout
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
from random import randint
t = int(stdin.readline())
for i in range(t):
	x = int(stdin.readline())
	if x % 7 == 1:
		stdout.write(str(x // 7 + 1) + '\n')
	else:
		stdout.write(str(x // 7 + 1) + '\n')


for _ in range(int(input())):
	x = int(input())
	ans = 0
	ans += x // 7
	if x % 7 != 0:
		ans += 1
	print(ans)


for i in range(int(input())):
	j = int(input())
	print(j // 2)


import random
t = input()
t = int(t)
x = []
for j in range(t):
	a = input()
	a = int(a)
	x.append(a)
g = max(x)
m = g // 7 + 1
y = 0
for i in range(len(x)):
	if x[i] == 1 or x[i] == 0:
		print(0)
	if x[i] == 2 or x[i] == 3:
		b = 1
		print(b)
	else:
		if x[i] // 7 == x[i] / 7:
			lower = x[i] // 7
		else:
			lower = x[i] // 7 + 1
		upper = x[i] // 2
		b = random.randint(lower, upper)
		print(b)


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,) = getIntList()
for _ in range(N):
	g = input()
	g = int(g)
	r = 1
	while g > 3:
		g -= 2
		r += 1
	print(r)


import math
ans = []
for _ in range(int(input())):
	n = int(input())
	ans.append(math.ceil(n / 7))
for i in ans:
	print(i)


for _ in range(int(input())):
	x = int(input())
	c = x // 7
	d = x % 7
	if d == 1:
		print(c + 2)
	elif d == 0:
		print(c)
	else:
		print(c + 1)


t = int(input())
dice = [2, 3, 4, 5, 6, 7]
while t:
	num = int(input())
	if num % 2 == 0:
		ans = num // 2
	elif num % 3 == 0:
		ans = num // 3
	elif num % 3 == 2:
		ans = num // 3 + 1
	elif num % 4 == 0:
		ans = num // 4
	elif num % 4 == 2:
		ans = num // 4 + 1
	elif num % 4 == 3:
		ans = num // 4 + 1
	elif num % 5 == 0:
		ans = num // 5
	elif num % 5 == 2:
		ans = num // 5 + 1
	elif num % 5 == 3:
		ans = num // 5 + 1
	elif num % 5 == 4:
		ans = num // 5 + 1
	elif num % 6 == 0:
		ans = num // 6
	elif num % 6 == 2:
		ans = num // 6 + 1
	elif num % 6 == 3:
		ans = num // 6 + 1
	elif num % 6 == 4:
		ans = num // 6 + 1
	elif num % 6 == 5:
		ans = num // 6 + 1
	elif num % 7 == 0:
		ans = num // 7
	elif num % 7 == 2:
		ans = num // 7 + 1
	elif num % 7 == 3:
		ans = num // 7 + 1
	elif num % 7 == 4:
		ans = num // 7 + 1
	elif num % 7 == 5:
		ans = num // 7 + 1
	elif num % 7 == 6:
		ans = num // 7 + 1
	print(ans)
	t -= 1


def solve():
	x = int(input())
	if x % 2 == 0:
		ans = x // 2
	else:
		ans = (x - 1) // 2
	print(ans)
t = int(input())
for j in range(t):
	solve()


t = int(input())
for i in range(t):
	x = int(input())
	print(x // 7 + min(1, x % 7))


t = int(input())
while t != 0:
	n = int(input())
	k = n // 2
	print(k)
	t -= 1


n = int(input())
for i in range(n):
	x = int(input())
	if x > 8:
		print(x // 7 + 1)
	elif x == 3 or x == 2:
		print(1)
	else:
		print(2)


n = int(input())

def func(n):
	if n % 2 == 0:
		print(n // 2)
	else:
		print((n - 3) // 2 + 1)
for i in range(n):
	func(int(input()))


T = int(input())
for t in range(T):
	n = int(input())
	ct = n // 7 + (n % 7 != 0)
	print(ct)


for t in range(int(input())):
	x = int(input())
	print(x // 2)


t = int(input())
for i in range(t):
	x = int(input())
	c = x // 7
	if x % 7 != 0:
		c += 1
	print(c)


T = int(input())
solutions = []

def numberOfRolls(x, listParam):
	while x != 0 and x >= 0:
		if x == 2:
			listParam.append(2)
			x = x - 2
		elif x == 3:
			listParam.append(3)
			x = x - 3
		elif x == 4:
			listParam.append(4)
			x = x - 4
		elif x == 5:
			listParam.append(5)
			x = x - 5
		elif x == 7:
			listParam.append(7)
			x = x - 7
		else:
			listParam.append(6)
			x = x - 6
	count = 0
	for x in listParam:
		count += 1
	return count
while T > 0:
	x = int(input())
	rolls = []
	y = numberOfRolls(x, rolls)
	solutions.append(y)
	T = T - 1
for x in solutions:
	print(x)


for i in range(int(input())):
	print((int(input()) + 6) // 7)


t = int(input())
for q in range(t):
	n = int(input())
	if n % 3 == 0:
		print(n // 3)
	elif n % 3 == 2:
		print(n // 3 + 1)
	else:
		print((n - 4) // 3 + 2)


n = int(input())
for x in range(n):
	s = 0
	n = int(input())
	s += n // 7 + 1
	print(s)


n = int(input())
for i in range(n):
	a = int(input())
	print((a + 7 - 1) // 7)


t = int(input())
for i in range(t):
	roll = int(input()) // 7 + 1
	print(roll)


def isRight(n, d):
	if n % d == 0:
		return (True, n // d)
	elif n % d >= 2 and n % d <= d - 1:
		return (True, n // d + 1)
	else:
		return (False, 0)
faces = [x for x in range(7, 1, -1)]
t = int(input())
tcases = []
for i in range(t):
	temp = int(input())
	tcases.append(temp)
for tcase in tcases:
	for face in faces:
		if tcase >= face:
			ans = isRight(tcase, face)
			if ans[0]:
				print(ans[1])
				break
			else:
				pass
		else:
			pass


t = int(input())
for a1 in range(t):
	count = 0
	n = int(input())
	if n > 7:
		while n > 7:
			n -= 7
			count += 1
	print(count + 1)


t = int(input())
while t > 0:
	s = int(input())
	print(s // 2)
	t = t - 1


t = int(input())
for testcase in range(t):
	n = int(input())
	print(n // 7 + 1)


noOfQuery = int(input())
for i in range(noOfQuery):
	roll_in = int(input())
	print(roll_in // 2)


import math
t = int(input())
for i in range(t):
	a = int(input())
	print(math.ceil(a / 7))


def main():
	for _ in range(int(input())):
		points = int(input())
		rolls = 0
		dice_side = 7
		while points:
			(quo, points) = divmod(points, dice_side)
			rolls += quo
			dice_side -= 1
		print(rolls)
main()


z = input
for _ in range(int(z())):
	x = int(z())
	print(x // 2)


t = int(input())
for i in range(t):
	x = int(input())
	if x % 2 == 1:
		print((x - 3) // 2 + 1)
	else:
		print(x // 2)


t = int(input())
count = 0
ans = []
while count < t:
	i = int(input())
	if i <= 7:
		ans.append(1)
	elif i % 7 == 0:
		ans.append(i // 7)
	else:
		ans.append(i // 7 + 1)
	count += 1
for y in ans:
	print(y)


t = int(input())
res = 0
for n in range(t):
	x = int(input())
	if x % 7 != 1 and x >= 7:
		res = x // 7 + 1
		print(res)
	elif x % 7 == 1 and x >= 7:
		res = x // 6 + 1
		print(res)
	elif 2 <= x < 7:
		print(1)


from math import ceil
t = int(input())
for _ in range(t):
	n = int(input())
	ans = ceil(n / 7)
	print(ans)


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

def fi():
	return float(input())

def si():
	return input()

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

def li():
	return list(mi())
import math
t = ii()
for i in range(t):
	n = ii()
	ans = math.ceil(n / 7)
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	c = 0
	a = 2
	temp = n
	while temp > 0 and a <= 7:
		c += temp // a
		temp %= a
		a += 1
	print(c)


def solve(num):
	ans = 0
	for i in range(7, 1, -1):
		while num - i > 1:
			num -= i
			ans += 1
	return ans + 1
for _ in range(int(input())):
	print(solve(int(input())))


import math
n = int(input())
queries = []
for i in range(n):
	queries.append(int(input()))
for i in range(n):
	print(math.ceil(queries[i] / 7))


n = int(input())
L = []
for i in range(n):
	a = int(input())
	if a >= 2 and a <= 7:
		L.append(1)
	else:
		L.append((a - 2) // 6 + 1)
for i in range(n):
	print(L[i])


import sys
t = int(sys.stdin.readline())
for i in range(t):
	v = int(sys.stdin.readline())
	if v % 7 != 1:
		print(int(v / 7) + 1)
	else:
		print(int(v / 7) + 2)


for x in range(int(input())):
	inp = int(input())
	print(inp // 2)


t = int(input())
while t > 0:
	x = int(input())
	for i in range(2, 8):
		if x % i != 1:
			v = i
			break
	if x % v == 0:
		print(x // v)
	else:
		print(x // v + 1)
	t = t - 1


n = int(input())
for i in range(n):
	x = int(input())
	print((x - 1) // 7 + 1)


t = int(input())
while t:
	c = 1
	x = int(input())
	if x <= 7:
		c = 1
	else:
		for i in range(7, 1, -1):
			y = x // i
			z = x % i
			if z > 1:
				c = y + 1
				break
			elif z == 0:
				c = y
				break
	print(c)
	t = t - 1


from math import ceil
t = int(input())
for i in range(0, t):
	num = int(input())
	print(ceil(num / 6))


t = int(input())
for T in range(t):
	a = int(input())
	ans = a // 7 + (a % 7 is not 0)
	print(ans)


def num_roll(x):
	remainder = x
	cnt = 0
	while remainder > 0:
		for i in range(2, 8):
			if remainder % i != 1:
				cnt += remainder // i
				remainder = remainder % i
				break
	return cnt
n = int(input())
for i in range(0, n):
	x = int(input())
	print(num_roll(x))


for _ in range(int(input())):
	x = int(input())
	for i in range(2, 8):
		if x % i != 1:
			print(x // i + int(bool(x % i)))
			break


import math
import sys
t = int(input())
line_t = []
for i in range(t):
	a = int(input())
	line_t.append(a)

def mode7(x):
	points = x
	idx = 1
	while points // 7 > 0:
		points = points - 7
		idx += 1
	return idx
for i in range(t):
	print(mode7(line_t[i]))


num_queries = int(input())
c = 0
while c < num_queries:
	soma = int(input())
	result = soma / 7
	if soma % 7 > 0:
		result += 1
	print(int(result))
	c += 1


t = int(input())
for _ in range(t):
	x = int(input())
	(q, r) = divmod(x, 7)
	if r == 1:
		print(q + 2)
	else:
		print(q + 1)


import math
t = int(input())
for case in range(t):
	n = int(input())
	print(math.ceil((n - 1) // 7 + 1))


numbers = [7, 6, 5, 4, 3, 2]

def _max_number(x):
	for number in numbers:
		if x >= number:
			return number
n = int(input())
for i in range(0, n):
	x = int(input())
	max_number = _max_number(x)
	inc = 0
	if x % max_number != 0:
		inc = 1
	print(int(x / max_number) + inc)


n = int(input())
l = [7, 6, 5, 4, 3, 2]
for i in range(n):
	a = int(input())
	sum = 0
	i = 0
	if a in l:
		print(1)
	else:
		print(a // 2)


t = int(input())
xs = list(map(lambda _: int(input()), range(0, t)))

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

def result(x):
	return ceil(x, 7)
for x in xs:
	print(result(x))


t = int(input())
for i in range(t):
	ans = 0
	a = int(input())
	while a >= 4:
		ans += 1
		a -= 2
	if a != 0:
		print(ans + 1)
	else:
		print(ans)


t = int(input())
v = [2, 3, 4, 5, 6, 7]
for i in range(t):
	c = 0
	x = int(input())
	i = 0
	while x != 0 and i < 6:
		if x // v[i] != 0:
			c += x // v[i]
			x %= v[i]
		i += 1
	print(c)


t = int(input())
q = list()
for i in range(t):
	q.append(int(input()))
t = [7, 6, 5, 4, 3, 2]
for no in q:
	for i in t:
		if no % i != 1:
			numbr = i
			break
	if no % numbr == 0:
		print(no // numbr)
	else:
		print(no // numbr + 1)


t = int(input())
for it in range(t):
	n = int(input())
	print(n // 2)


t = int(input())
while t > 0:
	a = int(input())
	print(a // 2)
	t = t - 1


t = int(input())
nums = [int(input()) for i in range(t)]
for k in nums:
	if k % 2 == 0:
		print(int(k / 2))
	elif k == 3:
		print('1')
	else:
		print(int((k - 3) / 2))


t = int(input())
ans = []
for _ in range(t):
	c = 0
	n = int(input())
	while n > 8:
		n -= 7
		c += 1
	if n == 8:
		c += 2
	elif n in [2, 3, 4, 5, 6, 7]:
		c += 1
	ans.append(c)
[print(i) for i in ans]


t = int(input())
lst = []
for i in range(t):
	a = int(input())
	lst.append(a // 7 + 1)
for i in lst:
	print(i)


def Dice():
	n = int(input())
	if n == 3:
		print(1)
	else:
		print(n // 2)
t = int(input())
for i in range(t):
	Dice()


a = int(input())
for i in range(0, a):
	b = int(input())
	c = b // 7 + 1
	print(c)


t = int(input())
ans = []
for _ in range(t):
	x = int(input())
	ans += [1 + (x - 1) // 7]
print('\n'.join(map(str, ans)))


col = int(input())
bros = []
count = 0
while count != col:
	br = int(input())
	bros.append(br)
	count += 1
num = 0
while num != col:
	nr = bros[num]
	out = 0
	num += 1
	while nr > 7:
		nr -= 7
		out += 1
	if nr != 0:
		out += 1
	print(out)


import sys, math
t = int(sys.stdin.readline())
for i in range(t):
	r = int(sys.stdin.readline())
	if r == 1:
		print(1)
	elif r == 3:
		print(1)
	elif r % 2 == 0:
		print(r // 2)
	else:
		print((r - 3) // 2)


n = int(input())
for i in range(n):
	z = int(input())
	print(z // 2)


a = int(input())
for i in range(a):
	b = int(input())
	print(b // 2)


n = int(input())
for item in range(n):
	counter = 0
	t = int(input())
	counter += t // 7 + 1
	print(counter)


t = int(input())
while t:
	t -= 1
	n = int(input())
	print(n // 2)


n = int(input())
q = []
for i in range(0, n):
	q.append(int(input()))
	sum = q[i]
	count = 0
	while sum != 0:
		if sum % 2 == 1:
			sum -= 3
			count += 1
		else:
			sum -= 2
			count += 1
	print(count)


t = int(input())
while t:
	n = int(input())
	p = 0
	sum = 0
	z = n
	while sum != z:
		if n % 7 != 1:
			if n in range(7, 101):
				p = p + 1
				sum = sum + 7
				n = n - 7
			if n in range(6, 7):
				p = p + 1
				sum = sum + 6
				n = n - 6
			if n in range(5, 6):
				p = p + 1
				sum = sum + 5
				n = n - 5
			if n in range(4, 5):
				p = p + 1
				sum = sum + 4
				n = n - 4
			if n in range(3, 4):
				p = p + 1
				sum = sum + 3
				n = n - 3
			if n in range(2, 3):
				p = p + 1
				sum = sum + 2
				n = n - 2
		else:
			n = n - 5
			sum = sum + 5
			p = p + 1
	print(p)
	t = t - 1


import math
import sys
import bisect
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	print(n // 7 + 1)


int_ = int(input())
for i in range(int_):
	k = int(input())
	num = (k + 3) // 4
	print(num)


import sys
answers = [-1] * 101
answers[0] = 0
dice = list(range(2, 8))
for i in range(2, 101):
	for roll in dice:
		if i - roll >= 0 and answers[i - roll] != -1:
			answers[i] = 1 + answers[i - roll]
n = int(sys.stdin.readline())
out_list = []
for i in range(n):
	cur = int(sys.stdin.readline())
	out_list.append(answers[cur])
for out in out_list:
	print(out)


def program():
	n = int(input())
	if n % 2 == 0:
		print(n // 2)
		return
	else:
		n = n - 3
		print(n // 2 + 1)
t = int(input())
for i in range(t):
	program()


num = int(input())
for i in range(num):
	x = int(input())
	if x < 8:
		print(1)
	else:
		print(x // 2)


T = int(input())
for t in range(T):
	n = int(input())
	d = 7
	ans = 0
	while d > 1:
		d -= 1
		ans += n // d
		n %= d
		if n == 0:
			print(ans)
			break


it = 0
its = int(input())
while it < its:
	s = int(input())
	print(str(s // 5 + 1))
	it = it + 1


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 array():
	return list(map(int, input().strip().split()))

def space_str():
	return input().strip().split()

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

def solve():
	arr = [7, 6, 5, 4, 3, 2]
	t = int(input())
	for _ in range(t):
		ans = 0
		n = int(input())
		for i in arr:
			if n > 0:
				if n % i == 0:
					ans += n // i
					n = n % i
				elif n % i in arr:
					ans += n // i
					n = n % i
			else:
				break
		print(ans)
solve()


t = int(input())
while t > 0:
	x = int(input())
	if x <= 7:
		t -= 1
		print(1)
		continue
	else:
		c = 0
		while x > 7:
			x -= 2
			c += 1
		print(c + 1)
	t -= 1


t = int(input())
for _ in range(t):
	num = int(input())
	print(num // 2)


for _ in range(int(input())):
	print(int(int(input()) / 7 + 1))


t = int(input())
m = 0
while m < t:
	n = int(input())
	c = 1
	while n > 7:
		n = n - 7
		c = c + 1
	print(c)
	m = m + 1


count = int(input())
flag = 0
while flag < count:
	sum = int(input())
	if sum % 2 == 0:
		print(int(sum / 2))
	else:
		print(int((sum - 3) / 2 + 1))
	flag += 1


n = int(input())
ans = []
for i in range(n):
	j = int(input())
	if j % 7 == 0:
		ans.append(str(j // 7))
	elif j % 5 == 0:
		ans.append(str(j // 5))
	elif j % 3 == 0:
		ans.append(str(j // 6 + j % 6 // 3))
	elif j % 2 == 0:
		ans.append(str(j // 4 + j % 4 // 2))
	else:
		ans.append(str(j // 5 + 1))
print('\n'.join(ans))


t = int(input())
for i in range(t):
	k = int(input())
	print(k // 7 + 1)


dp = [10 ** 10 for i in range(101)]
dp[2] = dp[3] = dp[4] = 1
dp[5] = dp[6] = dp[7] = 1
for i in range(8, 101):
	for j in range(2, i):
		dp[i] = min(dp[i], dp[j] + dp[i - j])
for _ in range(int(input())):
	print(dp[int(input())])


def x(n):
	if n <= 7:
		return 1
	elif n == 8:
		return 2
	elif n == 9:
		return 2
	else:
		return x(n - n // 2) + x(n - 1 - n // 2)
t = int(input())
a = []
for i in range(t):
	a.append(int(input()))
for j in a:
	print(x(j))


n = int(input())
lista = []
for i in range(n):
	lista.append(int(input()))
for i in range(n):
	print(int(lista[i] / 2))


t = int(input())
for cas in range(0, t):
	n = int(input())
	print(int(n / 2))


num = int(input())
for _ in range(num):
	target = int(input())
	print(1 + target // 7)


T = int(input())
for cas in range(T):
	n = int(input())
	if n % 2 == 0:
		print(n // 2)
	else:
		print((n - 3) // 2 + 1)


T = int(input())
for t in range(0, T):
	n = int(input())
	ans = 0
	while n > 7:
		n -= 2
		ans += 1
	if n != 0:
		ans += 1
	print(ans)


t = int(input())
for z in range(t):
	x = int(input())
	if 7 >= x >= 2:
		print(1)
	elif x % 2 == 0:
		print(x // 2)
	else:
		print((x - 3) // 2 + 1)


t = int(input())
A = [int(input()) for i in range(t)]
for a in A:
	print(-(-a // 7))


t = int(input())
m = [int(input()) for _ in range(t)]
for i in m:
	if i <= 7:
		print(1)
	else:
		print(i // 7 + (1 if i % 7 != 0 else 0))


n = int(input())
list = []
for i in range(n):
	t = int(input())
	list.append(int(t / 2))
for i in range(n):
	print(list[i])


q = int(input())
for i in range(q):
	x = int(input())
	k = 1
	while x != 0 and x > 7:
		x = x - 7
		k += 1
	print(k)


import math as m
for _ in range(int(input())):
	n = int(input())
	print(m.ceil(n / 6))


t = int(input())
for case in range(t):
	x = int(input())
	print(x // 7 + 1)


x = int(input())
for i in range(x):
	a = int(input())
	k = 0
	if a > 7:
		t = int(a / 7)
		a = a - 7 * t
		k = k + t
	if a > 0:
		a = 0
		k = k + 1
	print(k)


for _ in [0] * int(input()):
	print(0 - -int(input()) // 7)


n = int(input())
for i in range(n):
	a = int(input())
	b = 0
	while a >= 7:
		a -= 7
		b += 1
	if a > 0:
		b += 1
	print(b)


t = int(input())
for i in range(t):
	a = int(input())
	pas = a // 7
	print(pas + 1)


amount = int(input())
for i in range(amount):
	inputs = int(input())
	if not inputs % 7 == 1:
		print(inputs // 7 + 1)
	else:
		print(inputs // 7 + 2)


for i in range(int(input())):
	roll = 0
	num = int(input())
	if num <= 7:
		roll = 1
	else:
		roll += num // 7
		if num % 7 == 1:
			roll += 2
		else:
			roll += 1
	print(roll)


for _ in range(int(input())):
	x = int(input())
	if x == 3:
		print(1)
	else:
		print(x // 2)


import math
n = int(input())
for i in range(n):
	p = int(input())
	a = math.ceil(p / 7)
	print(a)


n = int(input())
for i in range(n):
	k = int(input())
	result = 0
	result = k // 7
	if k % 7 != 0:
		result += 1
	print(result)


n = int(input())
for _ in range(n):
	s = int(input())
	if s < 8:
		print(1)
	else:
		print(s // 7 + 1)


n = int(input())
angka = [2, 3, 4, 5, 6, 7]
for i in range(n):
	hasil = 0
	dice = int(input())
	for j in angka:
		if dice >= j:
			hasil += dice // j
			dice = dice % j
		if dice == 0:
			break
	print(hasil)


t = int(input())
a = [2, 3, 4, 5, 6, 7]
for i in range(t):
	x = int(input())
	if 1 < x <= 7:
		print(1)
	else:
		for i in range(len(a) - 1, -1, -1):
			if x % a[i] <= 7:
				m = x // a[i]
				if x % a[i] == 0:
					print(m)
				else:
					print(m + 1)
				break


n = int(input())
for i in range(n):
	x = int(input())
	prob = 0
	while x > 0:
		if x < 0:
			prob += 1
			x = 0
		x -= 7
		prob += 1
	print(prob)


from math import sqrt

def main():
	n = int(input())
	for i in range(n):
		c = int(input())
		print(c // 7 + (1 if c % 7 != 0 else 0))
main()


t = int(input())
result = []
for _ in range(t):
	x = int(input())
	count = x // 2
	result.append(count)
for x in result:
	print(x)


faces = [2, 3, 4, 5, 6, 7]
n = input()
n = int(n)
count = 0
for i in range(n):
	count = 0
	x = input()
	x = int(x)
	while x > 7 and x > 1:
		x -= 7
		count += 1
	print(count + 1)


t = int(input())
for _ in range(t):
	n = int(input())
	print(n // 6 + (n % 6 > 0))


t = int(input())
for i in range(t):
	n = int(input())
	sum = 0
	i = 7
	while n:
		k = n // i
		if k:
			n = n - k * i
			sum += k
		i -= 1
	print(sum)


number = int(input())
for i in range(number):
	n = int(input())
	print(n // 2)


a = int(input())
l = []
for i in range(a):
	b = int(input())
	l.append(b)
for i in l:
	if i // 7 == 1:
		print(i // 7 + 2)
	else:
		print(i // 7 + 1)


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)))
t = ini()
for _ in range(t):
	n = ini()
	print((n + 6) // 7)


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

def space_str():
	return input().strip().split()

def space_int():
	return map(int, input().strip().split())
arr = [7, 6, 5, 4, 3, 2]
t = int(input())
for _ in range(t):
	ans = 0
	n = int(input())
	for i in arr:
		if n > 0:
			if n % i == 0:
				ans += n // i
				n = n % i
			elif n % i in arr:
				ans += n // i
				n = n % i
		else:
			break
	print(ans)


n = int(input())
for _ in range(n):
	x = int(input())
	if 2 <= x <= 7:
		answer = 1
	elif x % 2 == 0:
		answer = x // 2
	else:
		answer = 1 + (x - 3) // 2
	print(answer)


n = int(input())
l = []
for i in range(n):
	k = int(input())
	l.append(k)
for i in range(n):
	p = l[i] // 7
	q = l[i] % 7
	if q == 0:
		print(p)
	else:
		print(p + 1)


n = int(input())
for x in range(n):
	s = 0
	a = int(input())
	for x in range(2, 8):
		if a % (9 - x) == 0:
			s += a // (9 - x)
			break
		elif a % (9 - x) != 1:
			s += a // (9 - x)
			a = a % (9 - x)
	print(s)


c = int(input())
for k in range(c):
	d = int(input())
	if d % 2 == 0:
		print(d // 2)
	else:
		print((d - 3) // 2 + 1)


q = int(input())
for i in range(q):
	point = int(input())
	ans = point // 5
	left = point % 5
	if left > 0:
		ans += 1
	print(ans)


import math
n = int(input())
ans = 0
for i in range(n):
	l = int(input())
	print(math.ceil(l / 7))


t = int(input())
l = []
for i in range(t):
	x = int(input())
	ans = x // 6
	if x % 6 != 0:
		ans += 1
	print(ans)


for i in range(int(input())):
	x = int(input())
	print(x // 7 + (x % 7 != 0))


n = int(input())
arr = []
for i in range(n):
	arr.append(int(input()))

def find(x):
	ans = 0
	for i in range(6, 1, -1):
		ans += x // i
		x = x % i
	return ans
for i in range(n):
	print(find(arr[i]), ' ')


n = int(input())
for i in range(n):
	k = int(input())
	print(k // 7 + 1)


t = int(input())
for i in range(t):
	a = int(input())
	if a <= 7:
		print(1)
	else:
		d = a // 7
		print(d + 1)


from math import ceil
for x in range(int(input())):
	print(ceil(int(input()) / 7))


from math import *
for _ in range(int(input())):
	j = ceil(int(input()) / 7)
	print(j)


for t in range(int(input())):
	k = int(input())
	out = 0
	if k % 2:
		out += 1
		k -= 3
	out += k // 2
	print(out)


t = int(input())
for i in range(t):
	n = int(input())
	c = 0
	p = 7
	while n > 0:
		if n % p > 1:
			c += n // p + 1
			break
		elif n % p == 0:
			c += n // p
			break
		else:
			p -= 1
	print(c)


t = int(input())
while t:
	t -= 1
	n = int(input())
	if n % 2:
		print((n - 3) // 2 + 1)
	else:
		print(n // 2)


t = int(input())
l = [int(input()) for i in range(t)]
d = [2, 3, 4, 5, 6, 7]
for i in l:
	if i % 2 == 0:
		print(i // 2)
	else:
		print((i - 3) // 2 + 1)


t = int(input())
for i in range(t):
	a = int(input())
	print(a // 2)


n = int(input())
for i in range(n):
	temp = int(input())
	div = 7
	rodadas = 0
	while True:
		if temp // div != 0:
			rodadas += temp // div
			temp = temp % div
		if temp == 0:
			break
		div -= 1
	print(rodadas)


l = []
for i in range(int(input())):
	n = int(input())
	l += [n // 2]
for i in l:
	print(i)


import math
t = int(input())
ans = []
for i in range(t):
	n = int(input())
	if n <= 7:
		ans.append(1)
	else:
		k = 0
		d = 7
		while n > 0 and d >= 2:
			if n - d >= d:
				k += 1
				n = n - d
			else:
				d = d - 1
		ans.append(k)
for i in range(t):
	print(ans[i])


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_strList_from_str = lambda : list(sys.stdin.readline().strip())
get_int = lambda : int(sys.stdin.readline().strip())
pt = lambda x: sys.stdout.write(str(x))
for _ in range(get_int()):
	n = get_int()
	temp = n
	start = 7
	while True:
		temp = n
		rolls = 0
		for i in range(start, 1, -1):
			rolls += temp // i
			temp = temp % i
		if temp == 0:
			break
		else:
			start -= 1
	print(rolls)


import math
n = int(input())
for i in range(n):
	x = float(input())
	print(math.ceil((x - 1) / 6.0))


for i in range(int(input())):
	x = int(input())
	y = x // 7
	if x <= 7:
		print(1)
	elif x % 7 >= 2:
		print(y + 1)
	else:
		y = x // 6
		if x % 6 == 0:
			print(y)
		else:
			print(y + 1)


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = int(input())
for tt in range(t):
	n = int(input())
	flag = 0
	for i in range(0, 100):
		for j in range(0, 100):
			if 2 * i + 3 * j == n:
				print(i + j)
				flag = 1
				break
		if flag:
			break
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


tc = int(input())
tc += 1
while tc - 1:
	tc -= 1
	x = int(input())
	if x % 2:
		print((x - 3) // 2 + 1)
	else:
		print(x // 2)


import math
list = [6, 5, 4, 3, 2]
n = int(input())
for i in range(n):
	count = 0
	y = int(input())
	for j in list:
		while y >= j:
			if y % j == 0:
				t = math.floor(y / j)
				count = count + t
				y = y % j
				break
			elif y % j > 0 and y > j and (y - j >= 2):
				y = y - j
				count = count + 1
			else:
				break
	print(count)


for i in range(int(input())):
	print((int(input()) + 3) // 4)


for i in range(int(input())):
	print(int(input()) // 7 + 1)


t = int(input())
for i in range(t):
	n = int(input())
	rolls = n // 5
	if n % 5 == 0:
		print(rolls)
	else:
		print(rolls + 1)


t = int(input())
for _ in range(t):
	n = int(input())
	print(n // 2)


t = int(input())
dice = [2, 3, 4, 5, 6, 7]
for _ in range(t):
	rolls = 0
	n = int(input())
	print(n // 2)


T = int(input())
for i in range(T):
	x = int(input())
	print(x // 2)


n = int(input())
for i in range(n):
	want = int(input())
	if want % 2 == 0:
		print(want // 2)
	else:
		print(str(1 + (want - 3) // 2))


n = int(input())
for i in range(n):
	n1 = int(input())
	count = 0
	for i in range(7, 1, -1):
		if n1 != 1:
			count += int(n1 // i)
			n1 %= i
		elif n1 == 1:
			count += 1
			break
	print(count)


t = int(input())
i = 0
while i != t:
	k = int(input())
	if k % 7 == 0:
		c = k / 7
	else:
		c = k / 7 + 1
	if k < 7:
		print(1)
	else:
		print(int(c))
	i += 1


for _ in range(int(input())):
	num = int(input())
	if num % 2 == 0:
		print(num // 2)
	else:
		print(1 + (num - 3) // 2)


t = int(input())
x = []
for i in range(t):
	x.append(int(input()))
for z in x:
	print(z // 2)


import math
a = int(input())
b = []
for i in range(a):
	print(math.ceil(int(input()) / 6))


T = int(input())
xT = [int(input()) for i in range(T)]
for i in range(T):
	print(-(-xT[i] // 7))


t = int(input())
for _ in range(t):
	x = int(input())
	if x <= 7:
		print(1)
	elif x % 7 == 0:
		print(int(x / 7))
	else:
		print(int(x / 7) + 1)


from math import *
for i in range(int(input())):
	k = int(input())
	print(ceil(k / 7))


import time

def calculateOptimalRolls(number):
	updN = number
	rolls = 0
	div7 = updN // 7
	if updN % 7 > 0:
		rolls = div7 + 1
	else:
		rolls = div7
	return rolls

def solve():
	queries = int(input())
	for x in range(queries):
		desiredN = int(input())
		print(calculateOptimalRolls(desiredN))
solve()


import math
num = int(input())
for i in range(num):
	d = int(input())
	print(d // 2)


t = int(input())
q = []
for i in range(t):
	a = int(input())
	if 2 <= a <= 7:
		q.append(1)
	elif a % 7 == 0:
		q.append(a // 7)
	elif a % 7 != 0:
		q.append(a // 7 + 1)
	elif a % 5 == 0:
		q.append(a // 5)
	else:
		q.append(a // 5 + 1)
for i in q:
	print(i)


def k(s):
	if s % 3 == 0:
		return s // 3
	else:
		return s // 3 + 1
for i in range(int(input())):
	print(k(int(input())))


t = int(input())
answs = []
for i in range(t):
	n = int(input())
	answs.append(n)
for i in range(t):
	print(answs[i] // 2)


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
t = int(input())
for i in range(t):
	x = int(input())
	print(-(-x // 7))


def m(n):
	count = 0
	while n > 2:
		for i in range(7, 1, -1):
			if n >= i:
				if n % i != 1:
					count += n // i
					n = n % i
				else:
					red = n // i
					red -= 1
					count += red
					n = n - red * i
	if count != 0:
		return count
	return 1
n = int(input())
for i in range(n):
	print(m(int(input())))


T = int(input())
for i in range(T):
	x = int(input())
	if x % 2 == 0:
		print(x // 2)
	else:
		print((x - 3) // 2 + 1)


t = int(input())
for i in range(t):
	s = input()
	k = int(s)
	if k % 7 != 0:
		ans = k // 7 + 1
	else:
		ans = k // 7
	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)
t = ini()
for _ in range(t):
	x = ini()
	s = 0
	for i in range(7, 1, -1):
		s += x // i
		x %= i
	if x != 0:
		s += 1
	print(s)


def main():
	for _ in range(int(input())):
		n = int(input())
		print((n + 6) // 7)
	return 0
main()


for i in range(int(input())):
	n = int(input())
	if n % 7 == 1:
		print(n // 7 - 1 + 2)
	else:
		print(n // 7 + 1)


t = int(input())
for i in range(t):
	k = 0
	x = int(input())
	if 2 <= x <= 7:
		print(1)
	else:
		k = x // 7 + 1
		print(k)


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 = I()
	l = [I() for _ in range(n)]
	for x in l:
		print(-(-x // 7))
main()


for _ in range(int(input())):
	n = int(input())
	count = 0
	while n != 0:
		if n // 7 >= 1 and n % 7 != 1:
			count += n // 7
			n = n % 7
		elif n // 6 >= 1 and n % 6 != 1:
			count += n // 6
			n = n % 6
		if n // 5 >= 1 and n % 5 != 1:
			count += n // 5
			n = n % 5
		if n // 4 >= 1 and n % 4 != 1:
			count += n // 4
			n = n % 4
		if n // 3 >= 1 and n % 3 != 1:
			count += n // 3
			n = n % 3
		if n // 2 >= 1 and n % 2 != 1:
			count += n // 2
			n = n % 2
	print(count)


def dfs(dices, l, s, x):
	if s == x:
		return l
	elif s < x:
		for dice in dices:
			current_level = dfs(dices, l + 1, s + dice, x)
			if current_level != -1:
				return current_level
		return -1
	else:
		return -1

def solve(x):
	dices = list(range(2, 8))
	s = 0
	l = 0
	return dfs(dices, l, s, x)

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


import sys
from sys import stdin, stdout
import math
n = sys.stdin.readline()
n = int(n)
for _ in range(n):
	num = sys.stdin.readline()
	num = int(num)
	soln = math.ceil(num / 7)
	print(soln)


num = int(input())
lst_r = list()
for c in range(0, num):
	cont = 0
	n = int(input())
	if n <= 7:
		cont = 1
	elif n <= 14:
		cont = 2
	elif n <= 21:
		cont = 3
	elif n <= 28:
		cont = 4
	elif n <= 35:
		cont = 5
	elif n <= 42:
		cont = 6
	elif n <= 49:
		cont = 7
	elif n <= 56:
		cont = 8
	elif n <= 63:
		cont = 9
	elif n <= 70:
		cont = 10
	elif n <= 77:
		cont = 11
	elif n <= 84:
		cont = 12
	elif n <= 91:
		cont = 13
	elif n <= 98:
		cont = 14
	elif n <= 100:
		cont = 15
	lst_r.append(cont)
for v in lst_r:
	print(v)


n = int(input())
count = []
for i in range(n):
	num = int(input())
	if int(num % 3) == 0:
		count.append(int(num / 3))
	else:
		count.append(int(num / 3) + 1)
for i in range(n):
	print(count[i])


from math import ceil
t = int(input())
for _ in range(t):
	i = int(input())
	res = ceil(i / 7)
	print(res)


j = int(input())
s = []
for a in range(j):
	s.append(int(input()))
d = []
for b in s:
	a = b
	c = 0
	while a != 0:
		if a > 7:
			a -= 7
			c += 1
		elif a <= 7:
			a -= a
			c += 1
	d.append(c)
for c in d:
	print(c)


def count(x):
	if x % 2 == 0:
		print(x // 2)
	elif x == 3:
		print(1)
	else:
		print((x - 3) // 2 + 1)
n = int(input())
for i in range(n):
	count(int(input()))


from sys import stdin
from sys import stdout
sprint = stdout.write
sinput = stdin.readline

def func():
	n = int(input())
	c = 0
	if n % 2 == 1:
		c = 1
		n -= 3
	c += n // 2
	print(c)
t = int(sinput())
while t != 0:
	t -= 1
	func()


def throw_cub():
	n = int(input())
	for i in range(n):
		k = int(input())
		if k % 7 == 1:
			count = k // 7 + 1
		else:
			count = k // 7 + (k % 7 > 0)
		print(count)
throw_cub()


for _ in range(int(input())):
	X = int(input())
	if X <= 7:
		print('1')
	elif X % 7 == 0:
		print(X // 7)
	else:
		print(X // 7 + 1)


t = int(input())
for i in range(t):
	x = int(input())
	count = 0
	while x % 2 != 0:
		x -= 3
		count += 1
	count += x // 2
	print(count)


t = int(input())
k = [2, 3, 4, 5, 6, 7]
for i in range(t):
	x = int(input())
	if x in k:
		print(1)
	else:
		for j in k:
			if x % j != 1 and x % j == 0:
				print(x // j)
				break
			elif x % j != 1 and x % j > 0:
				print(x // j + 1)
				break
			elif x % j == 1:
				continue


a = int(input())
for i in range(a):
	z = int(input())
	if z > 7:
		print(z // 4)
	else:
		print(1)


x = input()
y = int(x)
r = []
for e in range(y):
	a = 0
	w = int(input())
	if w <= 7:
		a = 1
	else:
		a += w // 7
		if w % 7 == 1:
			a += 2
		else:
			a += 1
	print(a)


exec('print((int(input())-1)//7+1);' * int(input()))


for i in range(int(input())):
	inp = int(input())
	if inp % 2:
		print((inp - 3) // 2 + 1)
	else:
		print(inp // 2)


n = int(input())
l = []
for i in range(n):
	a = int(input())
	k = 0
	c = 0
	while k < a:
		k += 7
		c += 1
	l.append(c)
for elem in l:
	print(elem)


t = int(input())
for i in range(t):
	l = int(input())
	if l > 7 and l % 7 != 0:
		print(int(l // 7 + 1))
	elif l % 7 == 0:
		print(int(l / 7))
	else:
		print(1)


n = int(input())
for i in range(n):
	num = int(input())
	print(num // 2)


t = int(input())
for i in range(t):
	points = int(input())
	total = 0
	if points > 7:
		a = int(points / 7)
		b = points % 7
		total = a + 1
		print(total)
	elif points <= 7:
		print('1')


for t in range(int(input())):
	n = int(input())
	c = 0
	if n % 7 == 1:
		pass
	else:
		c += n // 7
		n %= 7
	if n % 6 == 1:
		pass
	else:
		c += n // 6
		n %= 6
	if n % 5 == 1:
		pass
	else:
		c += n // 5
		n %= 5
	if n % 4 == 1:
		pass
	else:
		c += n // 4
		n %= 4
	if n % 3 == 1:
		pass
	else:
		c += n // 3
		n %= 3
	if n % 2 == 1:
		pass
	else:
		c += n // 2
		n %= 2
	print(c)


t = int(input())
queries = []
for i in range(t):
	queries.append(int(input()))
for q in queries:
	out = 0
	while q > 0:
		if q % 2 == 0:
			q = q - 2
			out += 1
		else:
			q = q - 3
			out += 1
	print(out)


t = int(input())
xmin = 2
xmax = 7
for i in range(t):
	x = int(input())
	if x in [2, 3, 4, 5, 6, 7]:
		print(1)
	else:
		x2 = x // 2
		p1 = x2 // 2
		p2 = x2 // 7
		print(p1 + p2)


def role_count(num):
	role = 0
	while num > 0:
		if num > 8:
			num -= 7
			role += 1
		elif num == 8:
			num = 0
			role += 2
		elif 2 <= num <= 7:
			num = 0
			role += 1
	return role
lists = []
n = int(input())
for i in range(n):
	num = int(input())
	like = role_count(num)
	lists.append(like)
for l in lists:
	print(l)


import sys
import math
t = int(input())
while t > 0:
	x = int(input())
	ans = math.ceil(x / 5)
	print(ans)
	t -= 1


read = lambda : [int(i) for i in input().split()]
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	ans = 0
	if n % 2:
		ans += 1
		n -= 3
	ans += n // 2
	print(ans)


d = []
n = int(input())
for i in range(n):
	b = int(input())
	d.append(b)
import random
for g in d:
	max = g // 2
	if g % 7 == 0:
		min = g // 7
	else:
		min = g // 7 + 1
	y = random.randint(min, max)
	print(y)


t = int(input())
while t > 0:
	x = int(input())
	if x < 8:
		print(1)
	elif x % 2:
		print((x - 3) // 2)
	else:
		print(x // 2)
	t -= 1


def solve():
	num = int(input())
	rolls = 0
	if 2 <= num < 7:
		print('1')
	elif num % 7 == 1:
		print(int(num / 7) - 1 + 2)
	elif num % 7 == 0:
		print(int(num / 7))
	else:
		print(int(num / 7) + 1)
num = int(input())
for x in range(num):
	solve()


import sys
import math
t = int(input())
for _ in range(t):
	a = int(input())
	for i in range(7, 1, -1):
		if a % i == 1:
			continue
		else:
			print(math.ceil(a / i))
			break


x = int(input())
y = [int(input()) for c in range(x)]
for c in range(x):
	print(y[c] // 7 + 1)


[[print(str(x // 7 + min(1, x % 7))) for x in [int(input())]] for i in range(int(input()))]


t = int(input())
mas = []
for i in range(t):
	mas.append(int(input()))
for j in mas:
	print(j // 7 + 1)


n = int(input())
for i in range(n):
	a = int(input()) + 1
	if 1 < a < 7:
		print(1)
	else:
		b = a // 6
		c = a % 6
		if c == 0:
			print(b)
		elif c == 1:
			print(b + 2)
		else:
			print(b + 1)


for _ in range(int(input())):
	n = int(input())
	ans = 0
	if n % 5 == 1:
		ans = n // 5
	else:
		ans = n // 5 + 1
	print(ans)


def rolling(n, times=0):
	if n < 2:
		return times
	else:
		n -= 6
		times += 1
		return rolling(n, times)
queries = int(input())
for _ in range(queries):
	n = int(input())
	print(rolling(n))


import math
import os
import random
import re
import sys
TC = int(input())
for i in range(0, TC):
	h = int(input())
	cnt = 0
	if h < 6:
		print(1)
	else:
		while h > 6:
			h = h - 6
			cnt = cnt + 1
		print(cnt + 1)


s = int(input())
for i in range(0, s):
	a = int(input())
	print(a // 2)


t = int(input())
for i in range(t):
	score = int(input())
	count = 0
	for side in range(7, 1, -1):
		if score >= side:
			count += score // side
			score = score % side
		else:
			continue
		if score == 0:
			break
		if score == 1:
			count += 1
			break
	else:
		print(-1)
	print(count)


t = int(input())
l = [0 for i in range(101)]
for i in range(2, 8):
	l[i] = 1
for j in range(8, 101):
	l[j] = 1 + l[j - 2]
while t:
	n = int(input())
	print(l[n])
	t = t - 1


def cal(a):
	l = [7, 6, 5, 4, 3, 2]
	c = 0
	for i in l:
		if a % i != 1:
			c += a // i
			a %= i
	print(c)
for i in range(int(input().strip())):
	cal(int(input().strip()))


import math
t = int(input())
while t != 0:
	t -= 1
	n = int(input())
	cnt = 0
	while n - 3 > 1:
		cnt += 1
		n -= 3
	while n - 2 >= 0:
		n -= 2
		cnt += 1
	print(cnt)


for i in range(int(input())):
	n = int(input())
	jlh = 1
	while n >= 7:
		n -= 7
		jlh += 1
	print(jlh)


n = int(input())
a = list()
res = 0
for i in range(n):
	x = int(input())
	a.append(x)
for x in a:
	res = 0
	while x >= 7:
		x -= 7
		res += 1
	while x < 7 and x > 0:
		res += 1
		break
	print(res)


t = int(input())
for i in range(0, t):
	q = int(input())
	print((q - 1) // 7 + 1)


a = int(input())
for i in range(a):
	b = int(input())
	d = (b - b % 6) / 6
	print(int(d + 1))


n = int(input())
ans = []
for i in range(n):
	x = int(input())
	ans.append(x // 2)
for i in range(n):
	print(ans[i])


n = int(input())
q = []
for i in range(0, n):
	q.append(int(input()))
for i in range(0, n):
	sum = q[i]
	count = 0
	while sum != 0:
		for j in range(7, 1, -1):
			if sum - j < 0 or sum - j == 1:
				continue
			else:
				sum -= j
				count += 1
			if sum == 0:
				break
	print(count)


t = int(input())
while t > 0:
	a = int(input())
	if a % 7 == 0:
		sum = a // 7
	else:
		sum = a // 7 + 1
	if a > 7:
		print(sum)
	else:
		print(1)
	t -= 1


t = int(input())
n = []
for i in range(t):
	c = int(input())
	n.append(c)
for i in range(t):
	print(n[i] // 6 + 1)


Input = []
y = 9
z = 0
ans = []
for i in range(int(input())):
	Input.append(int(input()))
for i in Input:
	num = 0
	for x in range(2, 8):
		z = i % x
		if 2 <= z <= 7:
			num = (i - z) / x + 1
		elif z == 0:
			num = i / x
	ans.append(int(num))
for x in ans:
	print(x)


t = int(input())
for i in range(0, t):
	x = int(input())
	if x > 1 and x < 8:
		print(1)
	else:
		a = int(x / 7)
		if x % 7 == 0:
			print(a)
		else:
			print(a + 1)


for i in range(int(input())):
	a = int(input())
	if a < 8:
		print('1')
	else:
		b = a // 7
		c = a % 7
		if c == 0:
			print(b)
		else:
			print(b + 1)


def find(x):
	result = 0
	if x > 0:
		if x % 2 != 0:
			result += 1
			x = x - 3
		else:
			result += 1
			x = x - 2
		return result + find(x)
	return result
n = int(input())
for i in range(n):
	x = int(input())
	result = find(x)
	print(result)


def main():
	from math import ceil
	n = int(input())
	for i in range(n):
		print(ceil(int(input()) / 7))
main()


point = 0
dice = list(reversed(range(2, 8)))
for _ in range(int(input())):
	point = int(input())
	current = 0
	count = 0
	while point > 0:
		for d in dice:
			if point >= d:
				if point == d:
					point -= d
					count += 1
					break
				else:
					while True:
						point -= d
						count += 1
						if point == 1:
							point = 0
							count += 1
						if point < d:
							break
			else:
				continue
	print(count)


t = int(input())
for i in range(t):
	x = int(input())
	ans = x // 7 + 1
	print(ans)


from math import *
t = eval(input())
for i in range(0, t):
	n = eval(input())
	print(floor(n / 2))


n = int(input())

def solve(n):
	result = []
	for i in range(0, n):
		x = int(input())
		result.append(int(x / 7) + 1)
	for j in range(len(result)):
		print(result[j])
solve(n)


for _ in range(int(input())):
	print((int(input()) + 6) // 7)


a = int(input())
x = int(0)
while x < a:
	b = int(input())
	if b % 2 == 0:
		print(int(b / 2))
	else:
		print(int((b - 3) / 2 + 1))
	x = x + 1


n = int(input())
y = []
for i in range(n):
	x = int(input())
	r = x % 2
	y.append(r + (x - r * 3) // 2)
for el in y:
	print(el)


def solve():
	x = int(input())
	ans = 0
	if x % 2 == 1:
		x -= 3
		ans += 1
	ans += x // 2
	return ans

def main():
	t = int(input())
	for i in range(t):
		print(solve())
main()


n = int(input())
for i in range(n):
	v = int(input())
	print(v // 7 + 1)


t = int(input())
for i in range(t):
	value = int(input())
	if value < 8:
		print(1)
	else:
		num = value / 7
		if int(num) == num:
			print(int(num))
		else:
			print(int(num + 1))


i = int(input())
while i:
	n = int(input())
	print((n + 6) // 7)
	i -= 1


def dice(x):
	if x <= 7:
		return 1
	if x % 2 == 0:
		return x // 2
	ans = 0
	while True:
		if x % 2 == 0:
			return ans + x // 2
		elif x >= 7:
			x -= 7
			ans += 1
		elif x >= 5:
			x -= 5
			ans += 1
		elif x >= 3:
			x -= 3
			ans += 1
t = int(input())
for i in range(t):
	x = int(input())
	print(dice(x))


t = int(input())
l = [2, 3, 4, 5, 6, 7]
for i in range(t):
	x = int(input())
	if x in l == True:
		print('1')
	else:
		p = x % 5
		if p == 0:
			print(x // 5)
		elif p == 1:
			print((x - 6) // 5 + 1)
		else:
			print(x // 5 + 1)


from math import ceil
result = []
number = int(input())
for a in range(number):
	data = int(input())
	result.append(ceil(data / 7))
for b in result:
	print(b)


import math
t = int(input())
for i in range(0, t):
	x = int(input())
	rolls = math.floor(x / 2)
	print(rolls)


t = int(input())
i = 0
anss = []
while i < t:
	i += 1
	ans = 0
	x = int(input())
	ans = x / 2
	if int(x / 2) != ans:
		ans = int(x / 2)
	anss.append(int(ans))
for x in anss:
	print(x)


import sys
from math import ceil, floor
input = sys.stdin.readline
t = int(input())
for zzz in range(t):
	n = int(input())
	print(n // 2)


print('\n'.join([(lambda x: str(x >> 1))(int(input())) for i in range(int(input()))]))


t = int(input())
for _ in range(t):
	x = int(input())
	ans = 0
	if x % 2:
		ans += 1
		x -= 3
		ans += x // 2
	else:
		ans = x // 2
	print(ans)


t = int(input())
while t > 0:
	v = int(input())
	c = 0
	for i in [2, 3, 5, 7]:
		if v >= i:
			c += v // i
			v = v % i
	print(c)
	t -= 1


x = int(input())
a = []
b = []
for i in range(x):
	a.append(int(input()))
for j in range(x):
	b.append(int(a[j] / 7))
	if a[j] % 7 != 0:
		b[j] = b[j] + 1
for k in range(x):
	print(str(b[k]) + '\n')


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(t,) = I()
while t:
	t -= 1
	(n,) = I()
	count = 0
	x = 0
	while x < n:
		x += 7
		count += 1
	print(count)


from math import floor
for _ in range(int(input())):
	x = int(input())
	print(floor(x / 7) + 1)


t = int(input())
v = []
k = []
for i in range(t):
	a = int(input())
	v.append(a)
	if a % 2 == 0:
		k.append(a / 2)
	else:
		k.append((a - 3) / 2 + 1)
for i in range(t):
	print(int(k[i]))


n = int(input())
for i in range(n):
	t = int(input())
	result = 0
	for i in range(7, 1, -1):
		while t >= i:
			t -= i
			result += 1
	if t == 1:
		result += 1
	print(result)


t = int(input())
for i in range(t):
	x = int(input())
	s = 0
	j = x % 7 if x < 7 else 7
	y = x
	k = 0
	while s != x:
		if s < x:
			s += y // j * j
			k += y // j
			y = y % s
			j = y if y < j - 1 else j - 1
		elif s > x:
			s -= j + 1
			y = s - y
	print(k)


t = int(input())
for i in range(t):
	a = int(input())
	print(a // 7 + min(1, a % 7))


def solve():
	results = []
	dice = [2, 3, 4, 5, 6, 7]
	for _ in range(int(input())):
		x = int(input())
		if x < 8:
			results.append(1)
			continue
		results.append(x // dice[-1] + (1 if x % dice[-1] != 0 else 0))
	print('\n'.join((str(k) for k in results)))
solve()


t = int(input())
a = []
for x in range(t):
	ele = int(input())
	p = ele / 2
	c = int(p)
	print(c)


import math as m
t = int(input())
for i in range(t):
	print(m.ceil(int(input()) / 7))


n = int(input())
for _ in range(n):
	a = int(input())
	c = 0
	for i in range(2, 8):
		c += a // i
		a -= a // i * i
	print(c)


a = int(input())
l = [int(input()) // 2 for i in range(a)]
for j in range(a):
	print(l[j])


n = int(input())
l = []
for _ in range(n):
	n1 = int(input())
	n2 = n1 // 7
	l.append(n2 + 1)
for i in l:
	print(i)


from operator import itemgetter
t = int(input())
for i in range(t):
	n = int(input())
	num = n // 2
	num2 = n // 7 + (n % 7 != 0)
	print(num)


x = int(input())
lst = []
for i in range(0, x):
	y = int(input())
	d = y // 6
	f = y % 6
	lst.append(d if f == 0 else d + 1)
print(*lst, sep='\n')


t = int(input())
for i in range(t):
	n = int(input())
	if n % 7 == 0:
		print(n // 7)
	elif n % 7 == 1:
		print(n // 7 + 2)
	else:
		print(n // 7 + 1)


t = int(input())
while t > 0:
	n = int(input())
	if n % 7 == 0:
		print(int(n / 7))
	else:
		print(int(n / 7) + 1)
	t -= 1


from math import ceil
for _ in range(int(input())):
	x = int(input())
	if x % 6 != 1:
		print(ceil(x / 6))
	else:
		print(x // 6)


n = int(input())
a = []
for i in range(n):
	a.insert(i, int(input()))
for i in range(n):
	p = a[i]
	if p <= 7:
		print(1)
	elif p % 10 > 4:
		print(p // 5 + 1)
	else:
		print(p // 5)


n = int(input())
for i in range(n):
	tmp = int(input())
	ans = tmp // 7 + (1 if tmp % 7 != 0 else 0)
	print(ans)


n = int(input())
I = []
for i in range(n):
	k = int(input())
	I.append(k)

def count_moves(n):
	l = list(range(2, 8))
	if n in l:
		return 1
	elif n % 7 > 1:
		return n // 7 + 1
	elif n % 7 == 0:
		return n // 7
	else:
		i = 6
		while i > 0:
			if n % i > 1:
				return n // i + 1
			elif n % i == 0:
				return n // i
			else:
				i -= 1
for i in range(n):
	print(count_moves(I[i]))


def mishka(num):
	return num // 2
t = int(input())
initial = []
for i in range(t):
	temp = int(input())
	initial.append(temp)
final = map(mishka, initial)
for element in final:
	print(element)


x = int(input())
arr = []
for i in range(x):
	arr.append(int(input()))
for i in range(x):
	if arr[i] % 7 != 1:
		if arr[i] % 7 == 0:
			print(arr[i] // 7)
		else:
			print(arr[i] // 7 + 1)
	elif arr[i] % 6 != 1:
		if arr[i] % 6 == 0:
			print(arr[i] // 6)
		else:
			print(arr[i] // 6 + 1)
	elif arr[i] % 5 != 1:
		if arr[i] % 5 == 0:
			print(arr[i] // 5)
		else:
			print(arr[i] // 5 + 1)
	elif arr[i] % 4 != 1:
		if arr[i] % 4 == 0:
			print(arr[i] // 4)
		else:
			print(arr[i] // 4 + 1)
	elif arr[i] % 3 != 1:
		if arr[i] % 3 == 0:
			print(arr[i] // 3)
		else:
			print(arr[i] // 3 + 1)
	else:
		print(arr[i] // 2)


import math
t = int(input())
for w in range(t):
	n = int(input())
	print(math.ceil(n / 7))


for j in range(int(input())):
	n = int(input())
	if n < 7:
		print('1')
	elif n % 7 == 0:
		print(n // 7)
	else:
		print(n // 7 + 1)


import sys
t = int(input())
for i in range(t):
	n = int(input())
	print(n // 2)
sys.exit()


t = int(input())
for _ in range(t):
	n = int(input())
	x = n // 7
	print(x + 1)


def give(no):
	n = 1
	amax = 7
	k = int(no / 7)
	if k == 0 or no == 7:
		return 1
	elif k == 1 or no == 14:
		return 2
	else:
		n = no % 7
		if n != 0:
			k = k + 1
		return k
n = int(input())
a = []
c = []
for i in range(0, n):
	b = int(input())
	a.append(b)
	c.append(give(b))
for i in c:
	print(i)


t = int(input())
for z in range(t):
	x = int(input())
	if x % 7 == 0:
		print(x // 7)
	elif x % 7 == 1:
		print(x // 6 + 1)
	else:
		print(x // 7 + 1)


t = int(input())
for i in range(t):
	n = int(input())
	summ = 0
	for k in range(7, 1, -1):
		if n >= k:
			div = n // k
			summ += div
			n -= div * k
			if n == 0:
				break
			elif n == 1:
				n += k
				summ -= 1
	print(summ)


n = int(input(''))
for i in range(0, n):
	s = int(input(''))
	print(int(s / 2))


def get_input(inputs_number: int=1) -> str:
	raw_input_data = ''
	for _ in range(inputs_number):
		n_tests = input()
		raw_input_data += n_tests + '\n'
		for _ in range(int(n_tests)):
			raw_input_data += input() + '\n'
	return raw_input_data.strip()

def process_input(raw_input_data: str):
	data = raw_input_data.split('\n')
	n_tests = data.pop(0)
	return [int(number) for number in data]

def solve(raw_input_data):
	points = process_input(raw_input_data)
	answer = ''
	for point in points:
		if point <= 7:
			answer += '1\n'
			continue
		if point % 2 == 0:
			answer += str(point // 2) + '\n'
		else:
			answer += str(point // 2 - 1) + '\n'
	return answer
while True:
	try:
		input_data = get_input()
		answer = solve(input_data)
		print(answer)
	except:
		break


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

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

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
nb_query = read_int()
for _ in range(nb_query):
	curr = read_int()
	(div, rem) = divmod(curr, 7)
	ans = div
	if rem == 0:
		ans = div
	else:
		ans += 1
	print(ans)


for i in range(int(input())):
	print(int(input()) // 6 + 1)


def brosok(variable):
	q = variable // 6
	variable -= q * 6
	if variable > 0:
		q += 1
	return q
t = int(input())
for i in range(t):
	a = int(input())
	print(brosok(a))


from math import ceil
t = int(input())
q = 0
for i in range(t):
	ti = int(input())
	if ti <= 7:
		print(1)
	else:
		print(ceil(ti / 7.0))


t = int(input())
for i in range(t):
	s = int(input())
	c = 7
	ans = 0
	while s != 0 and c >= 2:
		while s >= c:
			s -= c
			ans += 1
		c -= 1
	if s:
		print(ans + 1)
		continue
	print(ans)


t = int(input())
if 1 <= t <= 1000:
	for i in range(t):
		n = int(input())
		m = n // 7 + 1
		print(m)


n = int(input())
a = []
for i in range(n):
	a.append(int(input()) // 2)
for i in range(n):
	print(a[i])


N = int(input())
Score = []
Answ = []
for i in range(N):
	Score.append(int(input()))
	Answ.append(Score[i] // 7 + 1)
for j in range(N):
	print(Answ[j])


i = int(input())

def count_n(number):
	print(number // 2)
for i in range(i):
	count_n(int(input()))


n = int(input())
for i in range(n):
	inp = int(input())
	print(int((inp + 6) / 7))


n = int(input())
for i in range(n):
	count = 0
	a = int(input())
	count += int(a / 2)
	print(count)


for case in range(int(input())):
	k = int(input())
	if k % 2 == 0:
		print(k // 2)
	else:
		print((k - 3) // 2 + 1)


def main():
	n = int(input())
	for i in range(n):
		x = int(input())
		print((x + 6) // 7)
main()


t = int(input())
for _ in range(t):
	a = int(input())
	if a % 2 == 0:
		print(a // 2)
	else:
		print((a - 3) // 2 + 1)


n = int(input())
for i in range(n):
	a = int(input())
	if a > 5:
		if a % 5 == 1:
			print(a // 5)
		else:
			print(a // 5 + 1)
	else:
		print(1)


t = int(input())
for _ in range(t):
	n = int(input())
	ans = (n + 6) // 7
	print(ans)


for i in [0] * int(input()):
	a = int(input())
	print(-(-a // 5))


def ans(num):
	if num >= 2 and num <= 7:
		return 1
	elif num >= 8 and num <= 14:
		return 2
	else:
		return 1 + ans(num - 7)
s = int(input())
for i in range(1, s + 1):
	num = int(input())
	print(ans(num))


n = int(input())
a = [0] * n
for i in range(n):
	a[i] = int(input())
for each in a:
	print(each // 2)


n = int(input())
for i in range(n):
	a = int(input())
	count = 0
	flag = 0
	while a > 7:
		if a == 8:
			count = count + 2
			flag = 1
			break
		else:
			count = count + 1
			a = a - 7
	if flag == 1:
		print(count)
	else:
		print(count + 1)


for i in [0] * int(input()):
	print(int(input()) // 2)


t = int(input())
for test in range(t):
	n = int(input())
	ans = n // 10
	if n == 8 or n == 9:
		print(2)
	else:
		print(ans * 2 + 1)


t = int(input())
for i in range(t):
	x = int(input())
	ans = 0
	d = 7
	while x > 0:
		if d <= x:
			ans = ans + x // d
			x %= d
			d -= 1
		else:
			d -= 1
	print(ans)


for _ in range(int(input())):
	n = int(input()) + 1
	l = [99] * n
	l[::2] = range((n + 1) // 2)
	for step in range(3, 8):
		for (i, b) in enumerate(l[:]):
			for (c, j) in enumerate(range(i, n, step), b):
				l[j] = min(l[j], c)
	print(l[-1])


t = int(input())
s = []
for i in range(t):
	n = int(input())
	if n <= 7:
		s.append(1)
	elif n % 7 != 0:
		s.append(n // 7 + 1)
	else:
		s.append(n // 7)
for j in range(t):
	print(s[j])


t = int(input())
kol = 0
mas = []
for i in range(t):
	x = int(input())
	mas += [0]
	if x % 2 == 1:
		mas[i] += 1
		x -= 3
	mas[i] = mas[i] + x // 2
for i in range(len(mas)):
	print(mas[i])


for _ in range(int(input())):
	tmp = 0
	n = int(input())
	i = 7
	while n > 0:
		tmp += n // i
		n %= i
		i -= 1
	print(tmp)


import random
t = int(input())
sum = 0
count = 0
for i in range(t):
	x = int(input())
	sum = sum + random.randint(2, 7)
	count = count + 1
	while sum != x:
		if sum < x:
			sum = sum + random.randint(2, 7)
			count = count + 1
			continue
		elif sum > x:
			sum = 0
			count = 0
		else:
			count = count + 1
			break
	print(count)
	sum = 0
	count = 0


n = int(input())
queries = []
for i in range(n):
	queries.append(int(input()))
for q in queries:
	print(q // 7 + 1)


i = int(input())
for _ in range(i):
	o = int(input())
	print(o // 2)


dice_nums = [2, 3, 4, 5, 6, 7]

def number_of_rolls(x):
	for i in dice_nums[::-1]:
		if not x % i:
			return int(x / i)
	return int((x - 3) / 2)
n = int(input())
for _ in range(n):
	print(number_of_rolls(int(input())))


for i in range(int(input())):
	n = int(input())
	if n == 2 or n == 3 or n == 4 or (n == 5) or (n == 6) or (n == 7):
		print(1)
	else:
		print(round(n / 7) + 1)


n = int(input())
ans = []
for i in range(n):
	nbr = int(input())
	if nbr <= 7:
		ans.append(1)
	else:
		i = 0
		while nbr > 7:
			nbr -= 7
			i += 1
		if nbr <= 7 and nbr >= 2:
			i += 1
		else:
			i += 2
		ans.append(i)
for elt in ans:
	print(elt)


for i in range(int(input())):
	k = int(input())
	print(k // 7 + (k % 7 > 0))


from sys import stdin, stdout
nmbr = lambda : int(input())
lst = lambda : list(map(int, input().split()))
ans = [2832] * 102
l = [2, 3, 4, 5, 6, 7]
for v in l:
	ans[v] = 1
for i in range(101):
	for j in range(101):
		if ans[i] != 0 and ans[j] != 0:
			if i + j <= 101:
				ans[i + j] = min(ans[i + j], ans[i] + ans[j])
for _ in range(nmbr()):
	x = nmbr()
	print(ans[x])


a = int(input())
for i in range(a):
	b = int(input())
	if b <= 7:
		print(1)
	else:
		print(b // 7 + 1)


ans = 1

def numberOfRolls(n):
	global ans
	if n <= 1:
		return False
	if n == 0:
		return True
	if n >= 2 and n <= 7:
		return True
	else:
		for i in range(2, 8):
			if numberOfRolls(n - i):
				ans += 1
				return ans
			else:
				ans += 1
				numberOfRolls(n - i)
t = int(input())
for i in range(t):
	n = int(input())
	if n > 7:
		ans = 1
		print(numberOfRolls(n))
	else:
		print(1)


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import combinations
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()
t = [(-1, -1)] * 1000010

def create(a):
	global t, n
	for i in range(n, 2 * n):
		t[i] = (a[i - n], i - n)
	for i in range(n - 1, 0, -1):
		x = [t[2 * i], t[2 * i + 1]]
		x.sort(key=lambda x: x[0])
		t[i] = x[1]

def update(idx, value):
	global t, n
	idx = idx + n
	t[idx] = value
	while idx > 1:
		idx = idx // 2
		x = [t[2 * idx], t[2 * idx + 1]]
		x.sort(key=lambda x: x[0])
		t[idx] = x[1]
for _ in range(int(input())):
	n = int(input())
	for i in range(2, 8):
		if n % i == 0:
			print(n // i)
			break
		elif n % i > 1:
			print(n // i + 1)
			break


x = int(input())
spisok = []
for i in range(x):
	a = int(input())
	spisok.append(a)
for i in spisok:
	if i < 8:
		print(1)
	elif i > 7:
		print(i // 7 + 1)


t = int(input())
for _ in range(t):
	i = int(input())
	print(i // 2)


import sys
for _ in range(int(input())):
	print(int(int(input()) / 7) + 1)


import math
x = int(input())
while x != 0:
	y = int(input())
	print(math.ceil(y / 7))
	x = x - 1


n = int(input())
a = []
b = [2, 3, 4, 5, 6, 7]
for i in range(n):
	a.append(int(input()))
for i in a:
	for j in b:
		if i % j == 0:
			print(int(i / j))
			break
		elif i % j in b:
			print(int(i / j) + 1)
			break


a = int(input())
b = []
for i in range(0, a):
	b.append(int(input()))
	print(b[i] // 2)


for t in range(int(input())):
	n = int(input())
	g = n // 7
	print(g + 1)


x = input()
x = int(x)
for i in range(x):
	count = 0
	n = int(input())
	if n <= 7:
		count = 1
	else:
		count += n // 7
		if n % 7 == 1:
			count += 2
		else:
			count += 1
	print(count)


t = int(input())
for i in range(0, t):
	n = int(input())
	rem = n % 7
	q = n // 7
	if rem == 0:
		ans = q
	else:
		ans = q + 1
	print(ans)


import os
import heapq
import sys, threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10 ** 5)
from io import BytesIO, IOBase

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

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

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

def lcm(num1, num2):
	return num1 * num2 // gcd(num1, num2)

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

def check(n, m, arr):
	(c1, c2) = (1, 1)
	for i in range(n):
		for j in range(1, m):
			if arr[i][j] > arr[i][j - 1]:
				continue
			else:
				c1 = 0
				break
	for i in range(m):
		for j in range(1, n):
			if arr[j][i] > arr[j - 1][i]:
				continue
			else:
				c2 = 0
				break
	if c1 and c2:
		return True
	else:
		return False

def main():
	for _ in range(int(input())):
		n = int(input())
		print(n // 2)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


a = [2, 3, 4, 5, 6, 7]
x = input()
t = 0
R = []
while t < int(x):
	y = int(input())
	rounds = 0
	if y > 7:
		if y % 7 != 0:
			rounds = y // 7 + 1
		else:
			rounds = y // 7
	else:
		rounds = 1
	R.append(rounds)
	t += 1
for r in R:
	print(r)


n = int(input())
for i in range(n):
	x = int(input())
	if x % 2 == 0:
		b = x // 2
		print(b)
	else:
		b = (x - 1) // 2
		print(b)


def roll():
	x = int(input())
	print(int(x / 2))

def rollTime(targetSet):
	targetInitial = 0
	while targetInitial < targetSet:
		roll()
		targetInitial += 1
targetSet = int(input())
rollTime(targetSet)


n = int(input())
for item in range(n):
	a = int(input())
	if a <= 7:
		print(1)
	elif a % 2 == 0:
		print(a // 2)
	else:
		print((a - 2) // 2 + 1)


import math
num = int(input())
lst = []
for x in range(num):
	lst.append(int(input()))

def number_points(x):
	return math.ceil(x / 7)
for x in lst:
	print(number_points(x))


major = [7, 6, 5, 4, 3, 2]
for _ in range(int(input())):
	k = int(input())
	c = 0
	i = 0
	while k != 0:
		d = k % major[i]
		if d < k and d != 1:
			c += k // major[i]
			k = k % major[i]
		else:
			i += 1
	print(c)


T = int(input())
for _ in range(T):
	n = int(input())
	print(n // 2)


x = input()
x = int(x)
for i in range(x):
	y = input()
	y = int(y)
	cont = int(y / 7)
	if y % 7 != 0:
		cont += 1
	print(cont)


import math
for _ in range(int(input())):
	print(math.ceil(int(input()) / 7))


def dice_rolls(n):
	print(n // 2)
queries = int(input())
for i in range(queries):
	dice_rolls(int(input()))


t = int(input())
ar = []
for i in range(t):
	x = int(input())
	c = 0
	while x >= 3:
		x = x - 3
		c = c + 1
	while x >= 2:
		x = x - 2
		c = c + 1
	print(c)


def kubik(lst):
	a = list()
	for elem in lst:
		a.append((elem + 6) // 7)
	return a
t = int(input())
b = list()
for i in range(t):
	s = int(input())
	b.append(s)
print(*kubik(b), sep='\n')


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 = Scanner.int()
	print(n // 7 + int(n % 7 > 0))

def main():
	T = Scanner.int()
	for _ in range(T):
		solve()
main()


def solver():
	number = int(input())
	combinations = [2, 3, 4, 5, 6, 7]
	for i in combinations:
		if number % i == 0:
			return int(number / i)
	count = 1
	new_number = number - 3
	count = count + new_number // 2
	return count
n = int(input())
for i in range(n):
	print(solver())


t = int(input())
l = [7, 6, 5, 4, 3, 2]
for _ in range(t):
	s = 0
	u = int(input())
	for i in l:
		if u >= i and u % i != 1:
			s += u // i
			u = u % i
	print(s)


import math
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	if n % 7 == 0:
		print(n // 7)
	else:
		print(n // 7 + 1)


n = int(input())
while n > 0:
	print(int(input()) // 2)
	n -= 1


def func(x):
	if x % 2 == 0:
		return x // 2
	else:
		return func(x - 3) + 1
t = int(input())
for i in range(t):
	x = int(input())
	print(func(x))


def find_rolls(x):
	return 1 if x < 3 else x // 2 if x % 2 == 0 else (x - 1) // 2

def main():
	n_queries = int(input())
	for _ in range(n_queries):
		print(find_rolls(int(input())))
main()


n = int(input())
counter = 0
for i in range(n):
	print(int(input()) // 2)


def main():
	n = int(input())
	print(n // 2)
input = __import__('sys').stdin.readline
for test in range(int(input())):
	main()


t = int(input())
for q in range(t):
	a = int(input())
	if a == 2:
		num = 1
	elif a == 3:
		num = 1
	elif a == 4:
		num = 1
	elif a > 4:
		if a % 5 == 0:
			num = a // 5
		elif a % 5 != 0:
			num = a // 5 + 1
	print(num)


t = int(input())
while t:
	print((int(input()) + 6) // 7)
	t -= 1


t = int(input())
while t:
	x = int(input())
	if x % 7 == 0:
		print(x // 7)
	else:
		print(x // 7 + 1)
	t -= 1


def main():
	t = int(input())
	for i in range(t):
		x = int(input())
		solver(x)

def solver(x):
	result = x // 2
	print(result)
main()


for tc in range(0, int(input())):
	x = int(input())
	print(x // 2 if x % 2 == 0 else 1 + (x - 3) // 2)


from math import ceil
t = int(input())
ans = list(map(lambda x: str(ceil(int(input()) / 7)), range(t)))
print('\n'.join(ans))


import math
for _ in range(int(input())):
	x = int(input())
	print(x // 2)


n = int(input())
lisofm = []
for i in range(n):
	m = int(input())
	lisofm.append(m // 2)
for j in range(len(lisofm)):
	print(lisofm[j])


import math
for i in range(int(input())):
	print(math.ceil(int(input()) / 7))


x = input()
x = int(x)
round = []
for i in range(x):
	count = 0
	n = int(input())
	if n <= 7:
		count = 1
	else:
		count += n // 7
		if n % 7 != 0:
			count += 1
	round.append(count)
for r in round:
	print(r)


for _ in range(int(input())):
	num = int(input())
	if 2 <= num <= 7:
		print(1)
	elif num % 2 == 0:
		print(num // 2)
	else:
		print(num // 2 - 1 + 1)


t = int(input())
while t:
	n = int(input())
	if n >= 2 and n <= 7:
		print(1)
	elif n % 2:
		print((n - 3) // 2)
	else:
		print(n // 2)
	t -= 1


def main(x):
	count = 0
	if x % 2 == 1:
		x -= 3
		count += 1
	count += x // 2
	return count
t = int(input())
for i in range(t):
	x = int(input())
	out = main(x)
	print(out)


n = int(input())
for i in range(n):
	x = int(input())
	sol = 0
	if x % 2 == 1:
		sol += 1
		x -= 3
	sol += x // 2
	print(sol)


import sys
import math
sys.setrecursionlimit(100000)
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
t = inp()
for _ in range(t):
	n = inp()
	if n <= 7:
		print(1)
	elif n % 2:
		ans = (n - 3) // 2 + 1
		print(ans)
	else:
		print(n // 2)


ans = [int(input()) // 2 for i in range(int(input()))]
print(*ans, sep='\n')


x = int(input())
for l in range(x):
	y = int(input())
	if y % 2 == 0:
		print(y // 2)
	elif y % 3 == 0:
		print(y // 3)
	elif y % 3 == 2:
		print(y // 3 + 1)
	elif y % 4 == 0:
		print(y // 4)
	elif y % 4 == 2 or y % 4 == 3:
		print(y // 4 + 1)
	elif y % 5 == 0:
		print(y // 5)
	elif y % 5 == 2 or y % 5 == 3 or y % 5 == 4:
		print(y // 5 + 1)
	elif y % 6 == 0:
		print(y // 6)
	elif y % 6 == 2 or y % 6 == 3 or y % 6 == 4 or (y % 6 == 5):
		print(y // 6 + 1)
	elif y % 7 == 0:
		print(y // 7)
	elif y % 7 == 2 or y % 7 == 3 or y % 7 == 4 or (y % 7 == 5) or (y % 7 == 6):
		print(y // 7 + 1)


def solve(x):
	return x // 7 + (x % 7 > 0)
n = int(input())
for i in range(n):
	x = int(input())
	print(solve(x))


t = int(input())

def step_num(p):
	s = p // 7
	if p % 7 > 0:
		s += 1
	return s
for i in range(t):
	p = int(input())
	print(step_num(p))


def sol():
	x = int(input())
	d = [2, 3, 4, 5, 6, 7]
	found = False
	for i in d:
		if x % i == 0:
			print(x // i)
			found = True
			break
	if not found:
		print((x - 1) // 2)

def main():
	t = int(input())
	for i in range(t):
		sol()
main()


t = int(input())
for i in range(t):
	n = int(input())
	ans = n // 7
	n %= 7
	if n >= 1:
		ans += 1
	print(ans)


n = int(input())
w = 0
for i in range(n):
	m = int(input())
	print(m // 2)


x = int(input())
for i in range(x):
	count = 0
	p = int(input())
	count = p // 7
	if p % 7 == 0:
		print(count)
	else:
		print(count + 1)


for i in range(int(input())):
	n = int(input())
	print(n // 7 + (n % 7 > 0))


q = int(input())
for i in range(q):
	n = int(input())
	rest = 0 if n % 7 == 0 else 1
	print(n // 7 + rest)


n = int(input())
for i in range(n):
	j = int(input())
	print(j // 7 + 1)


n = int(input())
for i in range(0, n, 1):
	x = int(input())
	print(x // 2)


t = int(input())
while t:
	n = int(input())
	print(n // 7 + 1)
	t = t - 1


t = int(input())
for i in range(t):
	cnt = 0
	x = int(input())
	if x % 7 == 0:
		cnt = int(x / 7)
	elif x % 7 == 1:
		cnt = int(x / 7) + 2
	else:
		cnt = int(x / 7) + 1
	print(int(cnt))


def main():
	for _ in range(int(input())):
		n = int(input()) + 1
		l = [99] * n
		l[0] = 0
		for step in range(7, 1, -1):
			for (i, b) in enumerate(l[:]):
				for (c, j) in enumerate(range(i, n, step), b):
					l[j] = min(l[j], c)
				if l[-1] < 99:
					break
		print(l[-1])
main()


x = int(input())
b = list()
r = 0
while r < x:
	a = int(input())
	a = a // 7 + 1
	b.append(a)
	r = r + 1
r = 0
while r < len(b):
	print(b[r])
	r = r + 1


t = int(input())
while t:
	t = t - 1
	n = int(input())
	if n < 8:
		print('1')
	else:
		print(n // 7 + 2)


for i in range(int(input())):
	no = int(input())
	dice = [2, 3, 4, 5, 6, 7]
	for j in dice:
		if no % j == 0 or no % j > 1:
			rem = no % j
			if rem == 0:
				extra = 0
			else:
				extra = 1
			div = no // j
			print(div + extra)
			break


t = int(input())
for i in range(t):
	a1 = int(input())
	print(int(a1 / 7) + 1)


n_queries = int(input())
desired_n = []
for k in range(n_queries):
	desired_n.append(int(input()))
for i in desired_n:
	n_rolls = i // 2
	print(n_rolls)


t = int(input())
for i in range(t):
	n = int(input())
	if n % 2 == 0:
		print(int(n / 2))
	elif n == 2 or n == 3:
		print(1)
	else:
		d = 4
		print(int(n / d + 1))


import math
import collections
import bisect
import heapq
import time
import itertools
import sys
T = int(input())
for ti in range(T):
	x = int(input())
	ans = x // 7
	if x % 7 != 0:
		ans += 1
	print(ans)


t = input()
t = int(t)
for tt in range(0, t):
	n = input()
	n = int(n)
	ans = n // 7
	if n % 7 != 0:
		ans = ans + 1
	print(ans)


t = int(input())
for i in range(t):
	c = 0
	r = int(input())
	while r != 0:
		if r - 7 >= 0:
			r -= 7
		else:
			r = 0
		c += 1
	print(c)


x = int(input())
while x != 0:
	x -= 1
	n = int(input())
	i = 7
	c = 0
	while n != 0:
		c += n // i
		n = n % i
		i -= 1
	print(c)


n = int(input())
for i in range(n):
	a = int(input())
	if a < 8:
		print(1)
	elif a == 7:
		s = a // 7
		print(s)
	else:
		s = a // 7
		print(s + 1)


for _ in range(int(input())):
	q = int(input())
	ans = q // 2
	print(ans)


t = int(input())
for e in range(t):
	s = int(input())
	a = s // 2
	b = s // 3
	c = s // 4
	d = s // 5
	e = s // 6
	f = s // 7

	def malik(s):
		for i in range(f + 1):
			for j in range(e + 1):
				for k in range(d + 1):
					for l in range(c + 1):
						for m in range(b + 1):
							for n in range(a + 1):
								if i * 7 + j * 6 + k * 5 + l * 4 + m * 3 + n * 2 == s:
									return i + j + k + l + m + n
	print(malik(s))


for _ in range(int(input())):
	c = 0
	n = int(input())
	print(n // 2)


d = []
n = int(input())
for i in range(0, n):
	k = int(input())
	d.append(k)
for i in range(0, len(d)):
	if d[i] <= 7:
		print(1)
	else:
		count = 0
		k2 = d[i] % 7
		f = d[i] - d[i] / 7
		if k2 < 7:
			count += 1
		print(count + int(d[i] / 7))


dp = [0] * 105
for i in range(2, 8):
	dp[i] = 1
for i in range(8, 101):
	dp[i] = dp[i - 2] + 1
for i in range(int(input())):
	print(dp[int(input())])


for _ in range(int(input())):
	temp = int(input())
	cnt = 0
	while temp >= 7:
		temp -= 7
		cnt += 1
	if temp != 0:
		cnt += 1
	print(cnt)


t = int(input())
for j in range(t):
	n = int(input())
	print(n // 2)


T = int(input())
for _ in range(T):
	n = int(input())
	if n == 2 or n == 3:
		print(1)
	else:
		print(n // 2)


n1 = input()
n = int(n1)
for i in range(n):
	g = input()
	nums = int(g)
	gg = 0
	gg += nums // 7
	k = nums % 7
	if k == 0:
		print(gg)
	else:
		gg += 1
		print(gg)


from sys import stdin, stdout
from itertools import combinations
from collections import defaultdict, OrderedDict
import math

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

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

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

def stringIn():
	return stdin.readline().strip()
t = intIn()
for i in range(t):
	n = intIn()
	print(n // 2)


n = int(input())
for i in range(n):
	v = int(input())
	cnt = v // 7
	if v % 7 != 0:
		cnt += 1
	print(cnt)


TC = int(input())
for tc in range(TC):
	x = int(input())
	print((x + 6) // 7)


t = int(input())
for i in range(t):
	x = int(input())
	ans = 0
	if x % 2 == 1:
		ans += 1
		x -= 3
	ans += x // 2
	print(ans)


from sys import stdin, stdout
nmbr = lambda : int(input())
lst = lambda : list(map(int, input().split()))
for _ in range(nmbr()):
	x = nmbr()
	if x % 2 == 0:
		print(x // 2)
	elif x == 3:
		print(1)
	else:
		print(1 + (x - 3) // 2)


t = int(input())
for p in range(t):
	n = int(input())
	print(n // 7 + 1)


def mi():
	return map(int, input().split())
for _ in range(int(input())):
	n = int(input())
	if n <= 3:
		print(1)
	else:
		n -= 3
		print(1 + n // 2)


n = int(input())
for i in range(1, n + 1):
	m = int(input())
	print((m - 1) // 7 + 1)


def solve(n):
	l = [7, 6, 5, 4, 3, 2]
	i = 0
	while l[i] > n:
		i += 1
	l = l[i:len(l)]
	i = 0
	counter = n // l[0]
	n = n % l[0]
	if n == 1:
		n += 7
		counter -= 1
	while n > 0:
		if n - l[i] not in [0, 1]:
			n -= l[i]
			counter += 1
		else:
			i += 1
	print(counter)

def main():
	for i in range(int(input())):
		solve(int(input()))
main()


t = int(input())
for c in range(t):
	n = int(input())
	x = n // 7
	y = n % 7 != 0
	print(x + y)


for z in range(int(input())):
	n = int(input())
	if n % 6 == 0:
		print(n // 6)
	else:
		print(n // 6 + 1)


N = int(input())
X = [int(input()) for i in range(N)]
for i in range(N):
	(x, times) = (X[i], 0)
	while x > 0:
		times += 1
		x -= 7
	print(times)


t = int(input())
for i in range(t):
	n = int(input())
	r = 0
	for j in range(7, 0, -1):
		r = n // j + r
		n = n % j
	print(r)


test_case = int(input())
for _ in range(test_case):
	x = int(input())
	print((x + 7 - 1) // 7)


n = int(input())
b = []
for i in range(n):
	b.append(int(input()))
for i in range(n):
	f = 1
	for g in range(b[i]):
		if b[i] > 8:
			b[i] -= 7
			f += 1
		elif b[i] == 8:
			f += 1
			break
		else:
			break
	print(f)


t = int(input())
dice_list = [7, 6, 5, 4, 3, 2]
num_list = []
for i in range(t):
	x = int(input())
	num = 0
	if x <= dice_list[0]:
		num_list.append(1)
	else:
		for dice in dice_list:
			if x >= dice:
				num += int(x / dice)
				x %= dice
				if x == 0:
					num_list.append(num)
					break
				elif x == 1:
					num_list.append(num + 1)
					break
for num in num_list:
	print(num)


points = [7, 6, 5, 4, 3, 2]

def is_divisible(number):
	for i in points:
		if number % i == 0:
			return True
	return False

def get_number_of_rolls(score):
	if score == 0:
		return 0
	rolls = 0
	actual_score = 0
	for i in points:
		if score % i == 0:
			return score // i
	for i in points:
		mod = score % i
		if is_divisible(mod):
			return score // i + get_number_of_rolls(mod)
n = int(input())
for i in range(n):
	score = int(input())
	print(get_number_of_rolls(score))


from math import ceil
t = int(input())
for i in range(t):
	n = int(input())
	print(ceil(n / 7))


for _ in range(int(input())):
	n = int(input())
	print(-(-n // 7))


def throws(desired):
	if desired % 2:
		even = desired - 3
		remains = even // 2
		return remains + 1
	return desired // 2
n = int(input())
for _ in range(n):
	print(throws(int(input())))


import sys
number = int(sys.stdin.readline())
answers = []
counter = 0
for _ in range(number):
	now_number = int(sys.stdin.readline())
	for i in reversed(range(2, 8)):
		if now_number != 0 and now_number - now_number // i * i >= 2 or now_number - now_number // i * i == 0:
			counter += now_number // i
			now_number = now_number - now_number // i * i
	answers.append(counter)
	counter = 0
print(*answers, sep='\n')


a = [1, 1, 1, 1, 1, 1] + 94 * [0]
for i in range(6, 100):
	a[i] = min([a[i - 7], a[i - 6], a[i - 5], a[i - 4], a[i - 3], a[i - 2]]) + 1
q = []
for i in range(int(input())):
	q += [a[int(input()) - 1]]
for i in q:
	print(i)


for _ in range(int(input())):
	n = int(input())
	c = 0
	l = 7
	while l >= 2:
		v = n // l
		r = n % l
		if r == 1:
			l -= 1
			r = n
		else:
			c += v
			l -= 1
			n = r
	print(c)


gi = lambda : list(map(int, input().split()))
print('\n'.join([str((x - x % 2 * 3) // 2 + x % 2) for x in [gi()[0] for k in range(gi()[0])]]))


t = int(input())
for cas in range(0, t):
	n = int(input())
	print(int((n + 6) / 7))


for i in range(int(input())):
	c = int(input())
	if c % 7 == 0:
		print(c // 7)
	else:
		print(c // 7 + 1)


for _ in range(int(input())):
	n = int(input())
	if n % 2 is 0:
		print(n // 2)
	else:
		print((n - 1) // 2)


t = int(input())
a = [int(input()) for i in range(t)]
for i in range(len(a)):
	print(-1 * (-1 * a[i] // 7))


import math
t = int(input())
x = [None] * t
for y in range(t):
	x[y] = int(input())
for j in range(t):
	res = math.ceil(x[j] / 7)
	print(res)


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
n = int(input())
a = []
for i in range(n):
	x = int(input())
	a.append(1 + x // 7)
for i in range(len(a)):
	print(a[i])


n = int(input())
for i in range(n):
	m = int(input())
	k = m // 7
	if k * 7 == m:
		print(m // 7)
	else:
		print(m // 7 + 1)


t = int(input())
a = []
for j in range(t):
	temp = int(input())
	count = 0
	b = [7, 6, 5, 4, 3, 2]
	for i in b:
		if temp // i:
			if temp % i == 1:
				count += temp // i
				count = count - 1
				temp = temp - i * (temp // i - 1)
			else:
				count += temp // i
				temp = temp - i * (temp // i)
	print(count)


t = int(input())
for _ in range(t):
	n = int(input())
	c = 0
	while n > 0:
		if n > 7:
			n -= 7
			c += 1
		elif n == 1:
			c += 2
			n -= 1
		else:
			c += 1
			n -= n
	print(c)


import math as m
n = int(input())
for i in range(n):
	x = int(input())
	if x % 2 == 0:
		print(m.floor(x / 2))
	else:
		print(m.floor((x - 3) / 2) + 1)


for tc in range(int(input())):
	n = int(input())
	if n % 7 == 0:
		ans = n // 7
	else:
		ans = n // 7 + 1
	print(ans)


n = int(input())
a = []
for g in range(n):
	k = int(input())
	kol = 0
	if k % 2 == 0:
		kol = k // 2
	else:
		kol = (k - 3) // 2 + 1
	a.append(kol)
for i in a:
	print(i)


T = int(input())
for t in range(0, T):
	x = int(input())
	print(1 if x <= 7 else x // 7 + (1 if x % 7 else 0))


t = int(input())
for i in range(t):
	x = int(input())
	print(int(x / 6) + 1)


import sys
sys.setrecursionlimit(2000)
from collections import Counter
from math import ceil
t = [int(val) for val in input().split()][0]
for test in range(t):
	x = [int(val) for val in input().split()][0]
	print(int(ceil(float(x) / 7.0)))