

from typing import Any







class 			lowercase    :




				def __init__( self				,       snake_case	):
											snake_case_          =   data
											snake_case_          =   None




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







class 			lowercase    :




				def __init__( self	):
											snake_case_          =   None




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




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




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




				def __getitem__( self				,       snake_case	):
											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				,       snake_case				,       snake_case	):
											if not 0 <= index < len(self	):
																		raise ValueError('list index out of range.'	)
											snake_case_          =   self.head
											for _ in range(snake_case	):
																		snake_case_          =   current.next
											snake_case_          =   data




				def    a							( self				,       snake_case	):
											self.insert_nth(len(self	)				,       snake_case	)




				def    a							( self				,       snake_case	):
											self.insert_nth(0				,       snake_case	)




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




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




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




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




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




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




				def    a							( self	):
											snake_case_          =   None
											snake_case_          =   self.head

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





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   LinkedList()
							assert linked_list.is_empty() is True
							assert str(UpperCamelCase__				) == ""

							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(UpperCamelCase__				) == i
														linked_list.insert_nth(UpperCamelCase__       ,							i + 1				)
							assert str(UpperCamelCase__				) == "->".join(str(UpperCamelCase__				) for i in range(1       ,							11				)				)

							linked_list.insert_head(0				)
							linked_list.insert_tail(11				)
							assert str(UpperCamelCase__				) == "->".join(str(UpperCamelCase__				) 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(UpperCamelCase__				) == 9
							assert str(UpperCamelCase__				) == "->".join(str(UpperCamelCase__				) 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				):
														snake_case_          =   -i
							assert all(linked_list[i] == -i for i in range(0       ,							9				)				) is True

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





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   [
							    -9,
							    100,
							    Node(77345112				),
							    'dlrow olleH',
							    7,
							    5555,
							    0,
							    -1_92.5_55_55,
							    'Hello, world!',
							    77.9,
							    Node(10				),
							    None,
							    None,
							    12.20,
							]
							snake_case_          =   LinkedList()

							for i in test_input:
														linked_list.insert_tail(UpperCamelCase__				)

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

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

							# Delete the tail
							snake_case_          =   linked_list.delete_tail()
							assert result == 12.2
							assert (
							    str(UpperCamelCase__				) == "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
							snake_case_          =   linked_list.delete_nth(10				)
							assert result is None
							assert (
							    str(UpperCamelCase__				) == "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(UpperCamelCase__				)
							    == "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(UpperCamelCase__				)
							assert (
							    str(UpperCamelCase__				)
							    == "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(UpperCamelCase__				)
							    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
							    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
							)





def  __lowerCamelCase     (			):







							'''simple docstring'''






							from doctest import testmod

							testmod()

							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(UpperCamelCase__				)
							print('\nReading/changing Node data using indexing:'				)
							print(F'''Element at Position 1: {linked_list[1]}'''				)
							snake_case_          =   input('Enter New Value: '				).strip()
							print('New list:'				)
							print(UpperCamelCase__				)
							print(F'''length of linked_list is : {len(UpperCamelCase__				)}'''				)


if __name__ == "__main__":
					main()







def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   1
							snake_case_          =   2
							while i * i <= n:
														snake_case_          =   0
														while n % i == 0:
																					n //= i
																					multiplicity += 1
														n_divisors *= multiplicity + 1
														i += 1
							if n > 1:
														n_divisors *= 2
							return n_divisors





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   1
							snake_case_          =   1

							while True:
														i += 1
														t_num += i

														if count_divisors(UpperCamelCase__				) > 500:
																					break

							return t_num


if __name__ == "__main__":
					print(solution())




