





"""simple docstring"""



a_				=    float("""inf""")






class 	__snake_case      :





	"""simple docstring"""


	def __init__(					self      ,		__lowerCamelCase						):



					'''simple docstring'''




					__A					:		List[str]						=  [0] * n
					__A					:		List[Any]						=  [0] * n
					__A					:		List[Any]						=  [0] * n
					__A					:		Any						=  [[] for _ in range(__lowerCamelCase						)]

	def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase=0						):



					'''simple docstring'''




					self.adj[a].append([b, len(self.adj[b]						), c, 0]						)
					self.adj[b].append([a, len(self.adj[a]						) - 1, rcap, 0]						)

	def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase						):



					'''simple docstring'''




					if vertex == sink or not flow:
									return flow

					for i in range(self.ptr[vertex]      ,		len(self.adj[vertex]						)						):
									__A					:		str						=  self.adj[vertex][i]
									if self.lvl[e[0]] == self.lvl[vertex] + 1:
													__A					:		Dict						=  self.depth_first_search(e[0]      ,		__lowerCamelCase      ,		min(__lowerCamelCase      ,		e[2] - e[3]						)						)
													if p:
																	self.adj[vertex][i][3] += p
																	self.adj[e[0]][e[1]][3] -= p
																	return p
									__A					:		str						=  self.ptr[vertex] + 1
					return 0







	def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase						):



					'''simple docstring'''




					__A					:		int						=  0, source
					for l in range(31						):  # noqa: E741  l = 30 maybe faster for random data
									while True:
													__A					:		Any						=  [0] * len(self.q						), [0] * len(self.q						)
													__A					:		int						=  0, 1, 1
													while qi < qe and not self.lvl[sink]:
																	__A					:		Dict						=  self.q[qi]
																	qi += 1
																	for e in self.adj[v]:
																					if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
																									__A					:		str						=  e[0]
																									qe += 1
																									__A					:		Dict						=  self.lvl[v] + 1

													__A					:		int						=  self.depth_first_search(__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase						)
													while p:
																	flow += p
																	__A					:		Optional[Any]						=  self.depth_first_search(__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase						)

													if not self.lvl[sink]:
																	break

					return flow






a_				=    Dinic(10)
a_				=    0
a_				=    9
for vertex in range(1, 5):
							graph.add_edge(source, vertex, 1)
for vertex in range(5, 9):
							graph.add_edge(vertex, sink, 1)
for vertex in range(1, 5):
							graph.add_edge(vertex, vertex + 4, 1)

# Now we can know that is the maximum flow(source -> sink)
print(graph.max_flow(source, sink))











"""simple docstring"""



def 	__lowercase  (     snake_case_						:						Union[str, Any]		)     ->Optional[int]:



    '''simple docstring'''







    __A					:		Dict						=  [701, 301, 132, 57, 23, 10, 4, 1]
    for gap in gaps:
        for i in range(snake_case_       ,len(snake_case_		)		):
            __A					:		Tuple						=  collection[i]
            __A					:		Union[str, Any]						=  i
            while j >= gap and collection[j - gap] > insert_value:
                __A					:		Optional[int]						=  collection[j - gap]
                j -= gap
            if j != i:
                __A					:		Optional[int]						=  insert_value
    return collection


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       a_				=    input("""Enter numbers separated by a comma:\n""").strip()
       a_				=    [int(item) for item in user_input.split(""",""")]
       print(shell_sort(unsorted))




