






class        a__      :





		class        a__      :
				UpperCAmelCase_							:       Dict 					= '_prev', '_data', '_next'






				def __init__(      self							, lowercase__							, lowercase__							, lowercase__						)				->				List[Any]:
						__A    =							link_p
						__A    =							element
						__A    =							link_n






				def 					_lowerCamelCase					(      self						)				->				Optional[Any]:
						return (
						    F""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
						)






		def __init__(      self						)				->				Union[str, Any]:
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							self._trailer
				__A    =							self._header
				__A    =							0






		def __len__(      self						)				->				Tuple:
				return self._size






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				return self.__len__() == 0






		def 					_lowerCamelCase					(      self							, lowercase__							, lowercase__							, lowercase__						)				->				str:
				# Create new_node by setting it's prev.link -> header
				# setting it's next.link -> trailer
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							new_node
				__A    =							new_node
				self._size += 1
				return self






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				Tuple:
				__A    =							node._prev
				__A    =							node._next

				__A    =							successor
				__A    =							predecessor
				self._size -= 1
				__A    =							node._data
				__A    =							__A    =							__A    =							None
				del node
				return temp





class        a__      (	_DoublyLinkedBase		):






		def 					_lowerCamelCase					(      self						)				->				int:
				if self.is_empty():
						raise Exception("List is empty"						)
				return self._header._next._data






		def 					_lowerCamelCase					(      self						)				->				Optional[int]:
				if self.is_empty():
						raise Exception("List is empty"						)
				return self._trailer._prev._data






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				List[str]:
				return self._insert(self._header							, lowercase__							, self._header._next						)






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				int:
				return self._insert(self._trailer._prev							, lowercase__							, self._trailer						)






		def 					_lowerCamelCase					(      self						)				->				Tuple:
				if self.is_empty():
						raise IndexError("remove_first from empty list"						)
				return self._delete(self._header._next						)






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				if self.is_empty():
						raise IndexError("remove_first from empty list"						)
				return self._delete(self._trailer._prev						)









import math
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						math.log(2,   10   ) * number
    _lowercase     			=						round((log_number - int(_lowercase   )),   15   )

    return difference
def 							UpperCAmelCase   ( _lowercase = 678910   ):


    '''simple docstring'''



    _lowercase     			=						90
    _lowercase     			=						0

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

    while position < number:
        _lowercase     			=						log_difference(_lowercase   )

        if difference >= upper_limit:
            power_iterator += 93

        elif difference < lower_limit:
            power_iterator += 196

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

    return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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