





from typing import Any





class  _a							:




	def __init__( self						:		Any		, _SCREAMING_SNAKE_CASE						:		Any		)->	Dict:
			lowerCAmelCase__       :      Tuple   					= data
			lowerCAmelCase__       :      Any   					= None




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





class  _a							:




	def __init__( self						:		Optional[Any]		)->	List[Any]:
			lowerCAmelCase__       :      Union[str, Any]   					= None




	def __iter__( self						:		Optional[Any]		)->	Any:
			lowerCAmelCase__       :      List[str]   					= self.head
			while node:
					yield node.data
					lowerCAmelCase__       :      List[str]   					= node.next




	def __len__( self						:		List[str]		)->	int:
			return sum(1 for _ in self		)




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




	def __getitem__( self						:		Any		, _SCREAMING_SNAKE_CASE						:		int		)->	Any:


			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						:		List[Any]		, _SCREAMING_SNAKE_CASE						:		int		, _SCREAMING_SNAKE_CASE						:		Any		)->	None:


			if not 0 <= index < len(self		):
					raise ValueError('''list index out of range.'''		)
			lowerCAmelCase__       :      List[str]   					= self.head
			for _ in range(UpperCamelCase__		):
					lowerCAmelCase__       :      Optional[int]   					= current.next
			lowerCAmelCase__       :      List[Any]   					= data




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		Any		)->	None:
			self.insert_nth(len(self		)		, UpperCamelCase__		)




	def 							UpperCAmelCase__( self						:		str		, _SCREAMING_SNAKE_CASE						:		Any		)->	None:
			self.insert_nth(0		, UpperCamelCase__		)




	def 							UpperCAmelCase__( self						:		Dict		, _SCREAMING_SNAKE_CASE						:		int		, _SCREAMING_SNAKE_CASE						:		Any		)->	None:


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




	def 							UpperCAmelCase__( self						:		Tuple		)->	None:  # print every node data
			print(self		)




	def 							UpperCAmelCase__( self						:		Tuple		)->	Any:
			return self.delete_nth(0		)




	def 							UpperCAmelCase__( self						:		Dict		)->	Any:  # delete from tail
			return self.delete_nth(len(self		) - 1		)




	def 							UpperCAmelCase__( self						:		Optional[Any]		, _SCREAMING_SNAKE_CASE						:		int = 0		)->	Any:


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




	def 							UpperCAmelCase__( self						:		str		)->	bool:
			return self.head is None




	def 							UpperCAmelCase__( self						:		Any		)->	None:
			lowerCAmelCase__       :      List[str]   					= None
			lowerCAmelCase__       :      int   					= self.head

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






def 					lowerCamelCase_   (	):




		"""simple docstring"""






		lowerCAmelCase__       :      Optional[Any]   					= 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	):
				lowerCAmelCase__       :      str   					= -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 					lowerCamelCase_   (	):




		"""simple docstring"""






		lowerCAmelCase__       :      Union[str, Any]   					= [
		    -9,
		    100,
		    Node(77_345_112	),
		    "dlrow olleH",
		    7,
		    5_555,
		    0,
		    -1_92.5_55_55,
		    "Hello, world!",
		    77.9,
		    Node(10	),
		    None,
		    None,
		    12.20,
		]
		lowerCAmelCase__       :      int   					= 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
		lowerCAmelCase__       :      Union[str, Any]   					= 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
		lowerCAmelCase__       :      List[str]   					= 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
		lowerCAmelCase__       :      List[str]   					= 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 					lowerCamelCase_   (	):




		"""simple docstring"""






		from doctest import testmod

		testmod()

		lowerCAmelCase__       :      Optional[int]   					= 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]}'	)
		lowerCAmelCase__       :      Tuple   					= 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()








import random

from .binary_exp_mod import bin_exp_mod






def 					lowerCamelCase_   (	_a     ,       _a=1_000	):




		"""simple docstring"""






		if n < 2:
				return False

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

		# this means n is odd
		lowerCAmelCase__       :      int   					= n - 1
		lowerCAmelCase__       :      Any   					= 0
		while d % 2 == 0:
				d /= 2
				exp += 1

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


if __name__ == "__main__":
		lowerCamelCase						=		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)))




