
from __future__ import annotations

from collections.abc import Iterator
from typing import Any
class 					lowercase__:



	"""simple docstring"""




	def __init__(			self    :     List[str]			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	str:
					lowercase_	    =   data
					lowercase_	    =   None

class 					lowercase__:



	"""simple docstring"""




	def __init__(			self    :     Any			)			->	str:
					lowercase_	    =   None
					lowercase_	    =   None
	def __iter__(			self    :     str			)			->	Iterator[Any]:
					lowercase_	    =   self.head
					while self.head:
									yield node.data
									lowercase_	    =   node.next
									if node == self.head:
													break
	def __len__(			self    :     Tuple			)			->	int:
					return sum(1 for _ in self			)
	def __repr__(			self    :     Tuple			)			->	List[str]:
					return "->".join(str(SCREAMING_SNAKE_CASE_			) for item in iter(self			)			)
	def 		_lowercase    (			self    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	None:
					self.insert_nth(len(self			)			,				SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	None:
					self.insert_nth(0			,				SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Union[str, Any]			,				SCREAMING_SNAKE_CASE_    :     int			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	None:
					if index < 0 or index > len(self			):
									raise IndexError('''list index out of range.'''			)
					lowercase_	    =   Node(SCREAMING_SNAKE_CASE_			)
					if self.head is None:
									lowercase_	    =   new_node  # first node points itself
									lowercase_	    =   lowercase_	    =   new_node
					elif index == 0:  # insert at head
									lowercase_	    =   self.head
									lowercase_	    =   lowercase_	    =   new_node
					else:
									lowercase_	    =   self.head
									for _ in range(index - 1			):
													lowercase_	    =   temp.next
									lowercase_	    =   temp.next
									lowercase_	    =   new_node
									if index == len(self			) - 1:  # insert at tail
													lowercase_	    =   new_node
	def 		_lowercase    (			self    :     List[Any]			)			->	Dict:
					return self.delete_nth(0			)
	def 		_lowercase    (			self    :     Any			)			->	Any:
					return self.delete_nth(len(self			) - 1			)
	def 		_lowercase    (			self    :     List[str]			,				SCREAMING_SNAKE_CASE_    :     int = 0			)			->	Any:
					if not 0 <= index < len(self			):
									raise IndexError('''list index out of range.'''			)
					lowercase_	    =   self.head
					if self.head == self.tail:  # just one node
									lowercase_	    =   lowercase_	    =   None
					elif index == 0:  # delete head node
									lowercase_	    =   self.tail.next.next
									lowercase_	    =   self.head.next
					else:
									lowercase_	    =   self.head
									for _ in range(index - 1			):
													lowercase_	    =   temp.next
									lowercase_	    =   temp.next
									lowercase_	    =   temp.next.next
									if index == len(self			) - 1:  # delete at tail
													lowercase_	    =   temp
					return delete_node.data




	def 		_lowercase    (			self    :     List[Any]			)			->	bool:
					return len(self			) == 0




def 							a		(				):


				'''simple docstring'''
				lowercase_	    =   CircularLinkedList()
				assert len(snake_case__   ) == 0
				assert circular_linked_list.is_empty() is True
				assert str(snake_case__   ) == ""

				try:
								circular_linked_list.delete_front()
								raise AssertionError  # This should not happen
				except IndexError:
								assert True  # This should happen

				try:
								circular_linked_list.delete_tail()
								raise AssertionError  # This should not happen
				except IndexError:
								assert True  # This should happen

				try:
								circular_linked_list.delete_nth(-1   )
								raise AssertionError
				except IndexError:
								assert True

				try:
								circular_linked_list.delete_nth(0   )
								raise AssertionError
				except IndexError:
								assert True

				assert circular_linked_list.is_empty() is True
				for i in range(5   ):
								assert len(snake_case__   ) == i
								circular_linked_list.insert_nth(snake_case__		,  i + 1   )
				assert str(snake_case__   ) == "->".join(str(snake_case__   ) for i in range(1		,  6   )   )

				circular_linked_list.insert_tail(6   )
				assert str(snake_case__   ) == "->".join(str(snake_case__   ) for i in range(1		,  7   )   )
				circular_linked_list.insert_head(0   )
				assert str(snake_case__   ) == "->".join(str(snake_case__   ) for i in range(0		,  7   )   )

				assert circular_linked_list.delete_front() == 0
				assert circular_linked_list.delete_tail() == 6
				assert str(snake_case__   ) == "->".join(str(snake_case__   ) for i in range(1		,  6   )   )
				assert circular_linked_list.delete_nth(2   ) == 3

				circular_linked_list.insert_nth(2		,  3   )
				assert str(snake_case__   ) == "->".join(str(snake_case__   ) for i in range(1		,  6   )   )

				assert circular_linked_list.is_empty() is False


if __name__ == "__main__":
						import doctest

						doctest.testmod()






def 							a		(				snake_case__:   int   ):


				'''simple docstring'''
				if not isinstance(snake_case__		,  snake_case__   ):
								raise ValueError('''Input must be an integer'''   )
				if input_num <= 0:
								raise ValueError('''Input must be positive'''   )
				return sum(
				    divisor for divisor in range(1		,  input_num // 2 + 1   ) if input_num % divisor == 0   )


if __name__ == "__main__":
						import doctest

						doctest.testmod()




