




'''simple docstring'''


class 						a_				:




	def __init__(       self     :  str       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Optional[Any]=None       ,		__lowerCAmelCase     :  List[Any]=None      ):
							__snake_case						 =   data
							__snake_case						 =   previous
							__snake_case						 =   next_node




	def __str__(       self     :  Dict      ):
							return F'{self.data}'




	def   lowercase__   (       self     :  str      ):
							return self.data




	def   lowercase__   (       self     :  int      ):
							return self.next




	def   lowercase__   (       self     :  Optional[Any]      ):
							return self.previous





class 						a_				:




	def __init__(       self     :  Tuple       ,		__lowerCAmelCase     :  int      ):
							__snake_case						 =   head




	def __iter__(       self     :  Tuple      ):
							return self




	def   lowercase__   (       self     :  Union[str, Any]      ):
							if not self.current:
													raise StopIteration
							else:
													__snake_case						 =   self.current.get_data()
													__snake_case						 =   self.current.get_next()
													return value





class 						a_				:




	def __init__(       self     :  str      ):
							__snake_case						 =   None  # First node in list
							__snake_case						 =   None  # Last node in list




	def __str__(       self     :  Union[str, Any]      ):
							__snake_case						 =   self.head
							__snake_case						 =   []
							while current is not None:
													nodes.append(current.get_data()      )
													__snake_case						 =   current.get_next()
							return " ".join(str(__lowerCAmelCase      ) for node in nodes      )




	def __contains__(       self     :  Any       ,		__lowerCAmelCase     :  int      ):
							__snake_case						 =   self.head
							while current:
													if current.get_data() == value:
																			return True
													__snake_case						 =   current.get_next()
							return False




	def __iter__(       self     :  Union[str, Any]      ):
							return LinkedListIterator(self.head      )




	def   lowercase__   (       self     :  Any      ):
							if self.head:
													return self.head.get_data()
							return None




	def   lowercase__   (       self     :  Any      ):
							if self.tail:
													return self.tail.get_data()
							return None




	def   lowercase__   (       self     :  int       ,		__lowerCAmelCase     :  Node      ):
							if self.head is None:
													__snake_case						 =   node
													__snake_case						 =   node
							else:
													self.insert_before_node(self.head       ,		__lowerCAmelCase      )




	def   lowercase__   (       self     :  List[Any]       ,		__lowerCAmelCase     :  Node      ):
							if self.head is None:
													self.set_head(__lowerCAmelCase      )
							else:
													self.insert_after_node(self.tail       ,		__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[int]       ,		__lowerCAmelCase     :  int      ):
							__snake_case						 =   Node(__lowerCAmelCase      )
							if self.head is None:
													self.set_head(__lowerCAmelCase      )
							else:
													self.set_tail(__lowerCAmelCase      )




	def   lowercase__   (       self     :  str       ,		__lowerCAmelCase     :  Node       ,		__lowerCAmelCase     :  Node      ):
							__snake_case						 =   node
							__snake_case						 =   node.previous

							if node.get_previous() is None:
													__snake_case						 =   node_to_insert
							else:
													__snake_case						 =   node_to_insert

							__snake_case						 =   node_to_insert




	def   lowercase__   (       self     :  Tuple       ,		__lowerCAmelCase     :  Node       ,		__lowerCAmelCase     :  Node      ):
							__snake_case						 =   node
							__snake_case						 =   node.next

							if node.get_next() is None:
													__snake_case						 =   node_to_insert
							else:
													__snake_case						 =   node_to_insert

							__snake_case						 =   node_to_insert




	def   lowercase__   (       self     :  List[str]       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  int      ):
							__snake_case						 =   1
							__snake_case						 =   Node(__lowerCAmelCase      )
							__snake_case						 =   self.head
							while node:
													if current_position == position:
																			self.insert_before_node(__lowerCAmelCase       ,		__lowerCAmelCase      )
																			return
													current_position += 1
													__snake_case						 =   node.next
							self.insert_after_node(self.tail       ,		__lowerCAmelCase      )




	def   lowercase__   (       self     :  int       ,		__lowerCAmelCase     :  int      ):
							__snake_case						 =   self.head
							while node:
													if node.get_data() == item:
																			return node
													__snake_case						 =   node.get_next()
							raise Exception('Node not found'      )




	def   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  Optional[Any]      ):
							if (node := self.get_node(__lowerCAmelCase      )) is not None:
													if node == self.head:
																			__snake_case						 =   self.head.get_next()

													if node == self.tail:
																			__snake_case						 =   self.tail.get_previous()

													self.remove_node_pointers(__lowerCAmelCase      )




	@staticmethod
	def   lowercase__   (       __lowerCAmelCase     :  Node      ):
							if node.get_next():
													__snake_case						 =   node.previous

							if node.get_previous():
													__snake_case						 =   node.next

							__snake_case						 =   None
							__snake_case						 =   None




	def   lowercase__   (       self     :  Any      ):
							return self.head is None





def 						lowerCamelCase__   (				):
						pass


if __name__ == "__main__":
	import doctest

	doctest.testmod()







'''simple docstring'''


from math import isqrt, loga
def 						lowerCamelCase__   (				a							):
						__snake_case						 =   [True] * max_number
						for i in range(2    ,	isqrt(max_number - 1							) + 1							):
												if is_prime[i]:
																		for j in range(i**2    ,	a    ,	a							):
																								__snake_case						 =   False

						return [i for i in range(2    ,	a							) if is_prime[i]]
def 						lowerCamelCase__   (				a = 800800    ,	a = 800800							):
						__snake_case						 =   degree * loga(a							)
						__snake_case						 =   int(a							)
						__snake_case						 =   calculate_prime_numbers(a							)

						__snake_case						 =   0
						__snake_case						 =   0
						__snake_case						 =   len(a							) - 1
						while left < right:
												while (
												    prime_numbers[right] * loga(prime_numbers[left]							)
												    + prime_numbers[left] * loga(prime_numbers[right]							)
												    > upper_bound
												):
																		right -= 1
												hybrid_integers_count += right - left
												left += 1

						return hybrid_integers_count


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

