"""simple docstring"""



from typing import Any
class 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			data
										A__       :     Optional[Any]								=			None





			def __repr__(			self							):







										'''simple docstring'''


										return F'''Node({self.data})'''





class 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self							):







										'''simple docstring'''


										A__       :     Dict								=			None





			def __iter__(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			self.head
										while node:
																	yield node.data
																	A__       :     Dict								=			node.next





			def __len__(			self							):







										'''simple docstring'''


										return sum(1 for _ in self							)





			def __repr__(			self							):







										'''simple docstring'''


										return "->".join([str(snake_case_							) for item in self]							)





			def __getitem__(			self   ,      snake_case_							):







										'''simple docstring'''


										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_							):







										'''simple docstring'''


										if not 0 <= index < len(self							):
																	raise ValueError("""list index out of range."""							)
										A__       :     Optional[Any]								=			self.head
										for _ in range(snake_case_							):
																	A__       :     int								=			current.next
										A__       :     Any								=			data





			def 		lowerCamelCase					(			self   ,      snake_case_							):







										'''simple docstring'''


										self.insert_nth(len(self							)   ,      snake_case_							)





			def 		lowerCamelCase					(			self   ,      snake_case_							):







										'''simple docstring'''


										self.insert_nth(0   ,      snake_case_							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										if not 0 <= index <= len(self							):
																	raise IndexError("""list index out of range"""							)
										A__       :     str								=			Node(snake_case_							)
										if self.head is None:
																	A__       :     str								=			new_node
										elif index == 0:
																	A__       :     Union[str, Any]								=			self.head  # link new_node to head
																	A__       :     List[str]								=			new_node
										else:
																	A__       :     Tuple								=			self.head
																	for _ in range(index - 1							):
																								A__       :     Any								=			temp.next
																	A__       :     int								=			temp.next
																	A__       :     List[Any]								=			new_node





			def 		lowerCamelCase					(			self							):  # print every node data







										'''simple docstring'''


										print(self							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.delete_nth(0							)





			def 		lowerCamelCase					(			self							):  # delete from tail







										'''simple docstring'''


										return self.delete_nth(len(self							) - 1							)





			def 		lowerCamelCase					(			self   ,      snake_case_ = 0							):







										'''simple docstring'''


										if not 0 <= index <= len(self							) - 1:  # test if index is valid
																	raise IndexError("""List index out of range."""							)
										A__       :     str								=			self.head  # default first node
										if index == 0:
																	A__       :     Optional[int]								=			self.head.next
										else:
																	A__       :     Dict								=			self.head
																	for _ in range(index - 1							):
																								A__       :     Dict								=			temp.next
																	A__       :     str								=			temp.next
																	A__       :     List[str]								=			temp.next.next
										return delete_node.data





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.head is None





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[str]								=			None
										A__       :     Optional[Any]								=			self.head

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





def  _A(		):
							A__       :     Optional[Any]								=			LinkedList()
							assert linked_list.is_empty() is True
							assert str(lowerCAmelCase							) == ""

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

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

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

def  _A(		):
							A__       :     Optional[int]								=			[
							    -9,
							    100,
							    Node(7734_5112							),
							    """dlrow olleH""",
							    7,
							    5555,
							    0,
							    -192.5_5555,
							    """Hello, world!""",
							    77.9,
							    Node(10							),
							    None,
							    None,
							    12.20,
							]
							A__       :     Any								=			LinkedList()

							for i in test_input:
														linked_list.insert_tail(lowerCAmelCase							)

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

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

							# Delete the tail
							A__       :     Union[str, Any]								=			linked_list.delete_tail()
							assert result == 12.2
							assert (
							    str(lowerCAmelCase							) == "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
							A__       :     Union[str, Any]								=			linked_list.delete_nth(10							)
							assert result is None
							assert (
							    str(lowerCAmelCase							) == "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(lowerCAmelCase							)
							    == "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(lowerCAmelCase							)
							assert (
							    str(lowerCAmelCase							)
							    == "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(lowerCAmelCase							)
							    == "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()

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


if __name__ == "__main__":
				main()






"""simple docstring"""



import math
from collections.abc import Iterator
from itertools import takewhile

def  _A(		lowerCAmelCase							):

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5			,  int(math.sqrt(lowerCAmelCase							) + 1							)			,  6							):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True

def  _A(		):
							A__       :     List[str]								=			2
							while True:
														if is_prime(lowerCAmelCase							):
																					yield num
														num += 1

def  _A(		lowerCAmelCase = 200_0000							):
							return sum(takewhile(lambda lowerCAmelCase							: x < n			,  prime_generator()							)							)


if __name__ == "__main__":
				print(F'{solution() = }')





