


from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from typing import Any




class 					_UpperCamelCase :







							'''simple docstring'''
							_A  				=  ("_front", "_back", "_len")




							@dataclass
							class 					_UpperCamelCase :







														'''simple docstring'''
														_A  				=  None
														_A  				=  None
														_A  				=  None




							class 					_UpperCamelCase :







														'''simple docstring'''
														_A  				=  ("_cur",)







														def __init__(		self  :				Tuple		,				SCREAMING_SNAKE_CASE_  :				Deque._Node | None		):
																				_a     =			cur







														def __iter__(		self  :				List[Any]		):
																				return self







														def 		_UpperCAmelCase	(		self  :				Any		):
																				if self._cur is None:
																										# finished iterating
																										raise StopIteration
																				_a     =			self._cur.val
																				_a     =			self._cur.next_node

																				return val







							def __init__(		self  :				int		,				SCREAMING_SNAKE_CASE_  :				Iterable[Any] | None = None		):
													_a     =			None
													_a     =			None
													_a     =			0

													if iterable is not None:
																			# append every value to the deque
																			for val in iterable:
																									self.append(SCREAMING_SNAKE_CASE_		)







							def 		_UpperCAmelCase	(		self  :				int		,				SCREAMING_SNAKE_CASE_  :				Any		):
													_a     =			self._Node(SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		)
													if self.is_empty():
																			# front = back
																			_a     =			_a     =			node
																			_a     =			1
													else:
																			# connect nodes
																			_a     =			node
																			_a     =			self._back
																			_a     =			node  # assign new back to the new node

																			self._len += 1

																			# make sure there were no errors
																			assert not self.is_empty(), "Error on appending value."







							def 		_UpperCAmelCase	(		self  :				Tuple		,				SCREAMING_SNAKE_CASE_  :				Any		):
													_a     =			self._Node(SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		)
													if self.is_empty():
																			# front = back
																			_a     =			_a     =			node
																			_a     =			1
													else:
																			# connect nodes
																			_a     =			self._front
																			_a     =			node
																			_a     =			node  # assign new front to the new node

																			self._len += 1

																			# make sure there were no errors
																			assert not self.is_empty(), "Error on appending value."







							def 		_UpperCAmelCase	(		self  :				int		,				SCREAMING_SNAKE_CASE_  :				Iterable[Any]		):
													for val in iterable:
																			self.append(SCREAMING_SNAKE_CASE_		)







							def 		_UpperCAmelCase	(		self  :				Optional[Any]		,				SCREAMING_SNAKE_CASE_  :				Iterable[Any]		):
													for val in iterable:
																			self.appendleft(SCREAMING_SNAKE_CASE_		)







							def 		_UpperCAmelCase	(		self  :				Tuple		):
													assert not self.is_empty(), "Deque is empty."

													_a     =			self._back
													_a     =			self._back.prev_node  # set new back
													# drop the last node - python will deallocate memory automatically
													_a     =			None

													self._len -= 1

													return topop.val







							def 		_UpperCAmelCase	(		self  :				Union[str, Any]		):
													assert not self.is_empty(), "Deque is empty."

													_a     =			self._front
													_a     =			self._front.next_node  # set new front and drop the first node
													_a     =			None

													self._len -= 1

													return topop.val







							def 		_UpperCAmelCase	(		self  :				Optional[int]		):
													return self._front is None







							def __len__(		self  :				Tuple		):
													return self._len







							def __eq__(		self  :				Union[str, Any]		,				SCREAMING_SNAKE_CASE_  :				object		):

													if not isinstance(SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		):
																			return NotImplemented

													_a     =			self._front
													_a     =			other._front

													# if the length of the dequeues are not the same, they are not equal
													if len(self		) != len(SCREAMING_SNAKE_CASE_		):
																			return False

													while me is not None and oth is not None:
																			# compare every value
																			if me.val != oth.val:
																									return False
																			_a     =			me.next_node
																			_a     =			oth.next_node

													return True







							def __iter__(		self  :				Optional[int]		):
													return Deque._Iterator(self._front		)







							def __repr__(		self  :				int		):
													_a     =			[]
													_a     =			self._front
													while aux is not None:
																			# append the values in a list to display
																			values_list.append(aux.val		)
																			_a     =			aux.next_node

													return f"""[{', '.join(repr(SCREAMING_SNAKE_CASE_		) for val in values_list		)}]"""


if __name__ == "__main__":
		import doctest

		doctest.testmod()






import math


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  float:
						_a     =			math.log(2							,     10				) * number
						_a     =			round((log_number - int(_UpperCAmelCase				))							,     15				)

						return difference


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase = 678910				)    ->  int:
						_a     =			90
						_a     =			0

						_a     =			math.log(1.23							,     10				)
						_a     =			math.log(1.24							,     10				)
						_a     =			0

						while position < number:
												_a     =			log_difference(_UpperCAmelCase				)

												if difference >= upper_limit:
																		power_iterator += 93

												elif difference < lower_limit:
																		power_iterator += 196

												else:
																		_a     =			power_iterator
																		power_iterator += 196
																		position += 1

						return previous_power


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		print(f"""{solution() = }""")


