



from typing import Any


class       a							:



		def __init__(     self     :str   ,__lowercase     :Any  ):
						snake_case__	:      Optional[Any]     		=	data
						snake_case__	:      str     		=	None






		def __repr__(     self     :Optional[Any]  ):
						return F"""Node({self.data})"""


class       a							:



		def __init__(     self     :Tuple  ):
						snake_case__	:      Union[str, Any]     		=	None



		def __iter__(     self     :int  ):
						snake_case__	:      Dict     		=	self.head
						while node:
										yield node.data
										snake_case__	:      Dict     		=	node.next



		def __len__(     self     :List[Any]  ):
						return sum(1 for _ in self  )



		def __repr__(     self     :Union[str, Any]  ):
						return "->".join([str(__lowercase  ) for item in self]  )



		def __getitem__(     self     :Dict   ,__lowercase     :int  ):
						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     :Any   ,__lowercase     :int   ,__lowercase     :Any  ):
						if not 0 <= index < len(self  ):
										raise ValueError('''list index out of range.'''  )
						snake_case__	:      List[str]     		=	self.head
						for _ in range(__lowercase  ):
										snake_case__	:      str     		=	current.next
						snake_case__	:      str     		=	data



		def 	__lowerCamelCase			(     self     :Any   ,__lowercase     :Any  ):
						self.insert_nth(len(self  )   ,__lowercase  )



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :Any  ):
						self.insert_nth(0   ,__lowercase  )



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :int   ,__lowercase     :Any  ):
						if not 0 <= index <= len(self  ):
										raise IndexError('''list index out of range'''  )
						snake_case__	:      int     		=	Node(__lowercase  )
						if self.head is None:
										snake_case__	:      List[Any]     		=	new_node
						elif index == 0:
										snake_case__	:      Optional[Any]     		=	self.head  # link new_node to head
										snake_case__	:      List[Any]     		=	new_node
						else:
										snake_case__	:      Optional[Any]     		=	self.head
										for _ in range(index - 1  ):
														snake_case__	:      List[str]     		=	temp.next
										snake_case__	:      Dict     		=	temp.next
										snake_case__	:      int     		=	new_node



		def 	__lowerCamelCase			(     self     :List[str]  ):  # print every node data
						print(self  )



		def 	__lowerCamelCase			(     self     :List[Any]  ):
						return self.delete_nth(0  )



		def 	__lowerCamelCase			(     self     :Union[str, Any]  ):  # delete from tail
						return self.delete_nth(len(self  ) - 1  )



		def 	__lowerCamelCase			(     self     :Optional[int]   ,__lowercase     :int = 0  ):
						if not 0 <= index <= len(self  ) - 1:  # test if index is valid
										raise IndexError('''List index out of range.'''  )
						snake_case__	:      int     		=	self.head  # default first node
						if index == 0:
										snake_case__	:      Optional[Any]     		=	self.head.next
						else:
										snake_case__	:      Union[str, Any]     		=	self.head
										for _ in range(index - 1  ):
														snake_case__	:      int     		=	temp.next
										snake_case__	:      Optional[Any]     		=	temp.next
										snake_case__	:      List[str]     		=	temp.next.next
						return delete_node.data



		def 	__lowerCamelCase			(     self     :Dict  ):
						return self.head is None






		def 	__lowerCamelCase			(     self     :List[str]  ):
						snake_case__	:      str     		=	None
						snake_case__	:      Tuple     		=	self.head

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



def 			_lowerCAmelCase       (					)   ->					None:


				"""simple docstring"""

				snake_case__	:      str     		=	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      ):
								snake_case__	:      Union[str, Any]     		=	-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 			_lowerCAmelCase       (					)   ->					None:


				"""simple docstring"""

				snake_case__	:      Optional[int]     		=	[
				    -9,
				    100,
				    Node(77345112      ),
				    '''dlrow olleH''',
				    7,
				    5555,
				    0,
				    -192.55_555,
				    '''Hello, world!''',
				    77.9,
				    Node(10      ),
				    None,
				    None,
				    12.20,
				]
				snake_case__	:      int     		=	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
				snake_case__	:      Any     		=	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
				snake_case__	:      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
				snake_case__	:      Optional[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 			_lowerCAmelCase       (					)   ->					Any:


				"""simple docstring"""

				from doctest import testmod

				testmod()

				snake_case__	:      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]}"""      )
				snake_case__	:      str     		=	input('''Enter New Value: '''      ).strip()
				print('''New list:'''      )
				print(__lowerCAmelCase      )
				print(f"""length of linked_list is : {len(__lowerCAmelCase      )}"""      )


if __name__ == "__main__":
				main()






import random

from .binary_exp_mod import bin_exp_mod



def 			_lowerCAmelCase       (					__lowerCAmelCase  ,  __lowerCAmelCase=1000      )   ->					str:


				"""simple docstring"""

				if n < 2:
								return False

				if n % 2 == 0:
								return n == 2

				# this means n is odd
				snake_case__	:      Tuple     		=	n - 1
				snake_case__	:      Tuple     		=	0
				while d % 2 == 0:
								d /= 2
								exp += 1

				# n - 1=d*(2**exp)
				snake_case__	:      List[str]     		=	0
				while count < prec:
								snake_case__	:      List[str]     		=	random.randint(2  ,  n - 1      )
								snake_case__	:      Optional[Any]     		=	bin_exp_mod(__lowerCAmelCase  ,  __lowerCAmelCase  ,  __lowerCAmelCase      )
								if b != 1:
												snake_case__	:      List[Any]     		=	True
												for _ in range(__lowerCAmelCase      ):
																if b == n - 1:
																				snake_case__	:      List[str]     		=	False
																				break
																snake_case__	:      str     		=	b * b
																b %= n
												if flag:
																return False
												count += 1
				return True


if __name__ == "__main__":
				A__								=						abs(int(input('''Enter bound : ''').strip()))
				print('''Here\'s the list of primes:''')
				print(''', '''.join(str(i) for i in range(n + 1) if is_prime_big(i)))

