



def 			UpperCAmelCase__     (     lowercase__    ,							lowercase__    ,							lowercase__    ,							lowercase__ )			->   List[Any]:
						if start == end:
												return start if lst[start] > item else start + 1
						if start > end:
												return start

						__lowercase											=					(start + end) // 2
						if lst[mid] < item:
												return binary_search(lowercase__    ,							lowercase__    ,							mid + 1    ,							lowercase__ )
						elif lst[mid] > item:
												return binary_search(lowercase__    ,							lowercase__    ,							lowercase__    ,							mid - 1 )
						else:
												return mid






def 			UpperCAmelCase__     (     lowercase__ )			->   Optional[int]:
						__lowercase											=					len(lowercase__ )

						for index in range(1    ,							lowercase__ ):
												__lowercase											=					lst[index]
												__lowercase											=					binary_search(lowercase__    ,							lowercase__    ,							0    ,							index - 1 )
												__lowercase											=					lst[:pos] + [value] + lst[pos:index] + lst[index + 1 :]

						return lst






def 			UpperCAmelCase__     (     lowercase__    ,							lowercase__ )			->   int:
						if not left:
												return right

						if not right:
												return left

						if left[0] < right[0]:
												return [left[0], *merge(left[1:]    ,							lowercase__ )]

						return [right[0], *merge(lowercase__    ,							right[1:] )]






def 			UpperCAmelCase__     (     lowercase__ )			->   Optional[Any]:
						__lowercase											=					len(lowercase__ )
						__lowercase						,      __lowercase											=					[], []
						__lowercase											=					[lst[0]]
						__lowercase											=					[]
						__lowercase											=					1
						while i < length:
												if lst[i] < lst[i - 1]:
																		runs.append(lowercase__ )
																		__lowercase											=					[lst[i]]
												else:
																		new_run.append(lst[i] )
												i += 1
						runs.append(lowercase__ )

						for run in runs:
												sorted_runs.append(insertion_sort(lowercase__ ) )
						for run in sorted_runs:
												__lowercase											=					merge(lowercase__    ,							lowercase__ )

						return sorted_array






def 			UpperCAmelCase__     (     )			->   Optional[int]:
						__lowercase											=					[5, 9, 10, 3, -4, 5, 178, 92, 46, -18, 0, 7]
						__lowercase											=					tim_sort(lowercase__ )
						print(lowercase__ )


if __name__ == "__main__":
			main()










from __future__ import annotations

from typing import Generic, TypeVar

UpperCamelCase__			=    TypeVar("T")
class       _lowerCAmelCase (			Generic[T]      ):






			"""simple docstring"""





			def __init__(					self						:							int      ,  lowercase						:							T )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					data  # Assign data
									__lowercase											=					None  # Initialize next as null
									__lowercase											=					None  # Initialize prev as null





class       _lowerCAmelCase (			Generic[T]      ):






			"""simple docstring"""





			def __init__(					self						:							Any )    ->       None:
									"""simple docstring"""







									__lowercase											=					None





			def 		snake_case__      (					self						:							str      ,  lowercase						:							T )    ->       None:
									"""simple docstring"""







									if self.head is None:
															__lowercase											=					Node(lowercase )
									else:
															__lowercase											=					Node(lowercase )
															__lowercase											=					new_node
															__lowercase											=					self.head
															__lowercase											=					None
															__lowercase											=					new_node





			def 		snake_case__      (					self						:							Optional[Any] )    ->       T | None:
									"""simple docstring"""







									if self.head is None:
															return None
									else:
															assert self.head is not None
															__lowercase											=					self.head.data
															__lowercase											=					self.head.next
															if self.head is not None:
																					__lowercase											=					None
															return temp





			def 		snake_case__      (					self						:							Optional[Any] )    ->       T | None:
									"""simple docstring"""







									return self.head.data if self.head is not None else None





			def __len__(					self						:							List[str] )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.head
									__lowercase											=					0
									while temp is not None:
															count += 1
															__lowercase											=					temp.next
									return count





			def 		snake_case__      (					self						:							Optional[Any] )    ->       bool:
									"""simple docstring"""







									return self.head is None







			def 		snake_case__      (					self						:							Optional[Any] )    ->       None:
									"""simple docstring"""







									print("""stack elements are:""" )
									__lowercase											=					self.head
									while temp is not None:
															print(temp.data      ,  end="""->""" )
															__lowercase											=					temp.next


# Code execution starts here
if __name__ == "__main__":
			# Start with the empty stack
			UpperCamelCase__			=    Stack()

			# Insert 4 at the beginning. So stack becomes 4->None
			print("Stack operations using Doubly LinkedList")
			stack.push(4)

			# Insert 5 at the beginning. So stack becomes 4->5->None
			stack.push(5)

			# Insert 6 at the beginning. So stack becomes 4->5->6->None
			stack.push(6)

			# Insert 7 at the beginning. So stack becomes 4->5->6->7->None
			stack.push(7)

			# Print the stack
			stack.print_stack()

			# Print the top element
			print("\nTop element is ", stack.top())

			# Print the stack size
			print("Size of the stack is ", len(stack))

			# pop the top element
			stack.pop()

			# pop the top element
			stack.pop()

			# two elements have now been popped off
			stack.print_stack()

			# Print True if the stack is empty else False
			print("\nstack is empty:", stack.is_empty())





