code: 
  
  
  
  class        lowerCAmelCase_	:
  
  
  
         class        lowerCAmelCase_	:
                UpperCAmelCase__       :      int       =						"_prev", "_data", "_next"
                def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	int:
                   UpperCamelCase					:						List[str]					=			link_p
                   UpperCamelCase					:						str					=			element
                   UpperCamelCase					:						int					=			link_n
  
  
  
  
  
  
                def       snake_case_ (    self )  ->	Any:
                   return (
                       F""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
                   )
  
  
  
  
  
  
         def __init__(    self )  ->	Optional[Any]:
            UpperCamelCase					:						Union[str, Any]					=			self._Node(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						Optional[Any]					=			self._Node(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						Any					=			self._trailer
            UpperCamelCase					:						Union[str, Any]					=			self._header
            UpperCamelCase					:						List[Any]					=			0
         def __len__(    self )  ->	Optional[Any]:
            return self._size
         def       snake_case_ (    self )  ->	Dict:
            return self.__len__() == 0
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Any:
            # Create new_node by setting it's prev.link -> header
            # setting it's next.link -> trailer
            UpperCamelCase					:						str					=			self._Node(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						int					=			new_node
            UpperCamelCase					:						str					=			new_node
            self._size += 1
            return self
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	List[Any]:
            UpperCamelCase					:						Optional[Any]					=			node._prev
            UpperCamelCase					:						List[Any]					=			node._next
  
            UpperCamelCase					:						List[str]					=			successor
            UpperCamelCase					:						Any					=			predecessor
            self._size -= 1
            UpperCamelCase					:						Dict					=			node._data
            UpperCamelCase					:						str					=			None
            del node
            return temp
  
  
  
  
  
  
  class        lowerCAmelCase_	(						_DoublyLinkedBase							):
         def       snake_case_ (    self )  ->	Any:
            if self.is_empty():
               raise Exception('List is empty' )
            return self._header._next._data
         def       snake_case_ (    self )  ->	List[Any]:
            if self.is_empty():
               raise Exception('List is empty' )
            return self._trailer._prev._data
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	str:
            return self._insert(self._header,    SCREAMING_SNAKE_CASE_,    self._header._next )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
            return self._insert(self._trailer._prev,    SCREAMING_SNAKE_CASE_,    self._trailer )
         def       snake_case_ (    self )  ->	Union[str, Any]:
            if self.is_empty():
               raise IndexError('remove_first from empty list' )
            return self._delete(self._header._next )
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	int:
            if self.is_empty():
               raise IndexError('remove_first from empty list' )
            return self._delete(self._trailer._prev )
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import sys
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
     # base cases
     if abs(snake_case__			) == 1:
        return a, 0
     elif abs(snake_case__			) == 1:
        return 0, b
  
     UpperCamelCase			,  UpperCamelCase					:						Dict					=			a, b
     UpperCamelCase			,  UpperCamelCase					:						int					=			1, 0
     UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			0, 1
  
     while remainder != 0:
        UpperCamelCase					:						str					=			old_remainder // remainder
        UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			remainder, old_remainder - quotient * remainder
        UpperCamelCase			,  UpperCamelCase					:						List[Any]					=			coeff_a, old_coeff_a - quotient * coeff_a
        UpperCamelCase			,  UpperCamelCase					:						Optional[Any]					=			coeff_b, old_coeff_b - quotient * coeff_b
  
     # sign correction for negative numbers
     if a < 0:
        UpperCamelCase					:						Dict					=			-old_coeff_a
     if b < 0:
        UpperCamelCase					:						Any					=			-old_coeff_b
  
     return old_coeff_a, old_coeff_b
  def 	UpperCamelCase			(     )			->  Tuple:
     if len(sys.argv			) < 3:
        print('2 integer arguments required'			)
        return 1
     UpperCamelCase					:						Union[str, Any]					=			int(sys.argv[1]			)
     UpperCamelCase					:						Optional[int]					=			int(sys.argv[2]			)
     print(extended_euclidean_algorithm(snake_case__ ,  snake_case__			)			)
     return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  
  
  
  