
'''simple docstring'''







from typing import Any


class 			lowerCAmelCase :




		def __init__(				self					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= data
								_SCREAMING_SNAKE_CASE				= None




		def __repr__(				self      ):
								return F'Node({self.data})'


class 			lowerCAmelCase :




		def __init__(				self      ):
								_SCREAMING_SNAKE_CASE				= None




		def __iter__(				self      ):
								_SCREAMING_SNAKE_CASE				= self.head
								while node:
														yield node.data
														_SCREAMING_SNAKE_CASE				= node.next




		def __len__(				self      ):
								return sum(1 for _ in self      )




		def __repr__(				self      ):
								return "->".join([str(A__      ) for item in self]      )




		def __getitem__(				self					,						UpperCamelCase      ):
								if not 0 <= index < len(self      ):
														raise ValueError("list index out of range."      )
								for i, node in enumerate(self      ):
														if i == index:
																				return node
								return None




		def __setitem__(				self					,						UpperCamelCase					,						UpperCamelCase      ):
								if not 0 <= index < len(self      ):
														raise ValueError("list index out of range."      )
								_SCREAMING_SNAKE_CASE				= self.head
								for _ in range(A__      ):
														_SCREAMING_SNAKE_CASE				= current.next
								_SCREAMING_SNAKE_CASE				= data




		def     lowercase       (				self					,						UpperCamelCase      ):
								self.insert_nth(len(self      )					,						A__      )




		def     lowercase       (				self					,						UpperCamelCase      ):
								self.insert_nth(0					,						A__      )




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
								if not 0 <= index <= len(self      ):
														raise IndexError("list index out of range"      )
								_SCREAMING_SNAKE_CASE				= Node(A__      )
								if self.head is None:
														_SCREAMING_SNAKE_CASE				= new_node
								elif index == 0:
														_SCREAMING_SNAKE_CASE				= self.head  # link new_node to head
														_SCREAMING_SNAKE_CASE				= new_node
								else:
														_SCREAMING_SNAKE_CASE				= self.head
														for _ in range(index - 1      ):
																				_SCREAMING_SNAKE_CASE				= temp.next
														_SCREAMING_SNAKE_CASE				= temp.next
														_SCREAMING_SNAKE_CASE				= new_node




		def     lowercase       (				self      ):  # print every node data
								print(self      )




		def     lowercase       (				self      ):
								return self.delete_nth(0      )




		def     lowercase       (				self      ):  # delete from tail
								return self.delete_nth(len(self      ) - 1      )




		def     lowercase       (				self					,						UpperCamelCase = 0      ):
								if not 0 <= index <= len(self      ) - 1:  # test if index is valid
														raise IndexError("List index out of range."      )
								_SCREAMING_SNAKE_CASE				= self.head  # default first node
								if index == 0:
														_SCREAMING_SNAKE_CASE				= self.head.next
								else:
														_SCREAMING_SNAKE_CASE				= self.head
														for _ in range(index - 1      ):
																				_SCREAMING_SNAKE_CASE				= temp.next
														_SCREAMING_SNAKE_CASE				= temp.next
														_SCREAMING_SNAKE_CASE				= temp.next.next
								return delete_node.data




		def     lowercase       (				self      ):
								return self.head is None




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= None
								_SCREAMING_SNAKE_CASE				= self.head

								while current:
														# Store the current node's next node.
														_SCREAMING_SNAKE_CASE				= current.next
														# Make the current node's next point backwards
														_SCREAMING_SNAKE_CASE				= prev
														# Make the previous node be the current node
														_SCREAMING_SNAKE_CASE				= current
														# Make the current node the next node (to progress iteration)
														_SCREAMING_SNAKE_CASE				= next_node
								# Return prev in order to put the head at the end
								_SCREAMING_SNAKE_CASE				= prev



def 			_a		(	):
						_SCREAMING_SNAKE_CASE				= LinkedList()
						assert linked_list.is_empty() is True
						assert str(_SCREAMING_SNAKE_CASE  ) == ""

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

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

						for i in range(10  ):
												assert len(_SCREAMING_SNAKE_CASE  ) == i
												linked_list.insert_nth(_SCREAMING_SNAKE_CASE	,			i + 1  )
						assert str(_SCREAMING_SNAKE_CASE  ) == "->".join(str(_SCREAMING_SNAKE_CASE  ) for i in range(1	,			11  )  )

						linked_list.insert_head(0  )
						linked_list.insert_tail(11  )
						assert str(_SCREAMING_SNAKE_CASE  ) == "->".join(str(_SCREAMING_SNAKE_CASE  ) for i in range(0	,			12  )  )

						assert linked_list.delete_head() == 0
						assert linked_list.delete_nth(9  ) == 10
						assert linked_list.delete_tail() == 11
						assert len(_SCREAMING_SNAKE_CASE  ) == 9
						assert str(_SCREAMING_SNAKE_CASE  ) == "->".join(str(_SCREAMING_SNAKE_CASE  ) for i in range(1	,			10  )  )

						assert all(linked_list[i] == i + 1 for i in range(0	,			9  )  ) is True

						for i in range(0	,			9  ):
												_SCREAMING_SNAKE_CASE				= -i
						assert all(linked_list[i] == -i for i in range(0	,			9  )  ) is True

						linked_list.reverse()
						assert str(_SCREAMING_SNAKE_CASE  ) == "->".join(str(_SCREAMING_SNAKE_CASE  ) for i in range(-8	,			1  )  )



def 			_a		(	):
						_SCREAMING_SNAKE_CASE				= [
						    -9,
						    100,
						    Node(7734_5112  ),
						    "dlrow olleH",
						    7,
						    5555,
						    0,
						    -192.55_555,
						    "Hello, world!",
						    77.9,
						    Node(10  ),
						    None,
						    None,
						    12.20,
						]
						_SCREAMING_SNAKE_CASE				= LinkedList()

						for i in test_input:
												linked_list.insert_tail(_SCREAMING_SNAKE_CASE  )

						# Check if it's empty or not
						assert linked_list.is_empty() is False
						assert (
						    str(_SCREAMING_SNAKE_CASE  ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
						    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
						)

						# Delete the head
						_SCREAMING_SNAKE_CASE				= linked_list.delete_head()
						assert result == -9
						assert (
						    str(_SCREAMING_SNAKE_CASE  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
						    "Hello, world!->77.9->Node(10)->None->None->12.2"
						)

						# Delete the tail
						_SCREAMING_SNAKE_CASE				= linked_list.delete_tail()
						assert result == 12.2
						assert (
						    str(_SCREAMING_SNAKE_CASE  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
						    "Hello, world!->77.9->Node(10)->None->None"
						)

						# Delete a node in specific location in linked list
						_SCREAMING_SNAKE_CASE				= linked_list.delete_nth(10  )
						assert result is None
						assert (
						    str(_SCREAMING_SNAKE_CASE  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
						    "Hello, world!->77.9->Node(10)->None"
						)

						# Add a Node instance to its head
						linked_list.insert_head(Node("Hello again, world!"  )  )
						assert (
						    str(_SCREAMING_SNAKE_CASE  )
						    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
						    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
						)

						# Add None to its tail
						linked_list.insert_tail(_SCREAMING_SNAKE_CASE  )
						assert (
						    str(_SCREAMING_SNAKE_CASE  )
						    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
						    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
						)

						# Reverse the linked list
						linked_list.reverse()
						assert (
						    str(_SCREAMING_SNAKE_CASE  )
						    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
						    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
						)



def 			_a		(	):
						from doctest import testmod

						testmod()

						_SCREAMING_SNAKE_CASE				= LinkedList()
						linked_list.insert_head(input("Inserting 1st at head "  ).strip()  )
						linked_list.insert_head(input("Inserting 2nd at head "  ).strip()  )
						print("\nPrint list:"  )
						linked_list.print_list()
						linked_list.insert_tail(input("\nInserting 1st at tail "  ).strip()  )
						linked_list.insert_tail(input("Inserting 2nd at tail "  ).strip()  )
						print("\nPrint list:"  )
						linked_list.print_list()
						print("\nDelete head"  )
						linked_list.delete_head()
						print("Delete tail"  )
						linked_list.delete_tail()
						print("\nPrint list:"  )
						linked_list.print_list()
						print("\nReverse linked list"  )
						linked_list.reverse()
						print("\nPrint list:"  )
						linked_list.print_list()
						print("\nString representation of linked list:"  )
						print(_SCREAMING_SNAKE_CASE  )
						print("\nReading/changing Node data using indexing:"  )
						print(F'Element at Position 1: {linked_list[1]}'  )
						_SCREAMING_SNAKE_CASE				= input("Enter New Value: "  ).strip()
						print("New list:"  )
						print(_SCREAMING_SNAKE_CASE  )
						print(F'length of linked_list is : {len(_SCREAMING_SNAKE_CASE  )}'  )


if __name__ == "__main__":
						main()

'''simple docstring'''







def 			_a		(	_SCREAMING_SNAKE_CASE		:   int  ):
						_SCREAMING_SNAKE_CASE				= int(_SCREAMING_SNAKE_CASE  )
						if n_element < 1:
												_SCREAMING_SNAKE_CASE				= ValueError("a should be a positive number"  )
												raise my_error

						_SCREAMING_SNAKE_CASE				= [1]
						_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= (0, 0, 0)
						_SCREAMING_SNAKE_CASE				= 1
						while index < n_element:
												while hamming_list[i] * 2 <= hamming_list[-1]:
																		i += 1
												while hamming_list[j] * 3 <= hamming_list[-1]:
																		j += 1
												while hamming_list[k] * 5 <= hamming_list[-1]:
																		k += 1
												hamming_list.append(
												    min(hamming_list[i] * 2	,			hamming_list[j] * 3	,			hamming_list[k] * 5  )  )
												index += 1
						return hamming_list


if __name__ == "__main__":
						_snake_case				:   int     =				input("""Enter the last number (nth term) of the Hamming Number Series: """)
						print("""Formula of Hamming Number Series => 2^i * 3^j * 5^k""")
						_snake_case				:   str     =				hamming(int(n))
						print("""-----------------------------------------------------""")
						print(F"The list with nth numbers is: {hamming_numbers}")
						print("""-----------------------------------------------------""")