

class 						lowercase_					:



      class 						lowercase_					:
            UpperCamelCase_    :	str		   =       "_prev", "_data", "_next"



            def __init__(    self   :       Tuple    ,      A__   :       Tuple    ,      A__   :       List[str]    ,      A__   :       Union[str, Any]	)					->  List[Any]:
              _snake_case		=      link_p
              _snake_case		=      element
              _snake_case		=      link_n







            def 		UpperCamelCase_	(    self   :       str	)					->  Tuple:
              return (
                  f""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
              )



      def __init__(    self   :       int	)					->  Any:
        _snake_case		=      self._Node(__A    ,      __A    ,      __A	)
        _snake_case		=      self._Node(__A    ,      __A    ,      __A	)
        _snake_case		=      self._trailer
        _snake_case		=      self._header
        _snake_case		=      0



      def __len__(    self   :       Optional[int]	)					->  Union[str, Any]:
        return self._size



      def 		UpperCamelCase_	(    self   :       Optional[int]	)					->  Tuple:
        return self.__len__() == 0



      def 		UpperCamelCase_	(    self   :       Dict    ,      A__   :       List[Any]    ,      A__   :       List[Any]    ,      A__   :       Optional[int]	)					->  Optional[Any]:
        _snake_case		=      self._Node(__A    ,      __A    ,      __A	)
        _snake_case		=      new_node
        _snake_case		=      new_node
        self._size += 1
        return self







      def 		UpperCamelCase_	(    self   :       Tuple    ,      A__   :       Optional[int]	)					->  int:
        _snake_case		=      node._prev
        _snake_case		=      node._next

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



class 						lowercase_					(						_DoublyLinkedBase  ):



      def 		UpperCamelCase_	(    self   :       Optional[Any]	)					->  int:







        if self.is_empty():
          raise Exception('''List is empty'''	)
        return self._header._next._data



      def 		UpperCamelCase_	(    self   :       int	)					->  List[Any]:







        if self.is_empty():
          raise Exception('''List is empty'''	)
        return self._trailer._prev._data



      def 		UpperCamelCase_	(    self   :       List[Any]    ,      A__   :       Optional[Any]	)					->  Any:
        return self._insert(self._header    ,      __A    ,      self._header._next	)



      def 		UpperCamelCase_	(    self   :       Union[str, Any]    ,      A__   :       Tuple	)					->  List[Any]:
        return self._insert(self._trailer._prev    ,      __A    ,      self._trailer	)



      def 		UpperCamelCase_	(    self   :       int	)					->  Tuple:







        if self.is_empty():
          raise IndexError('''remove_first from empty list'''	)
        return self._delete(self._header._next	)







      def 		UpperCamelCase_	(    self   :       Any	)					->  Dict:







        if self.is_empty():
          raise IndexError('''remove_first from empty list'''	)
        return self._delete(self._trailer._prev	)




__A    	=			{
    '''+''': lambda x, y: x + y,
    '''-''': lambda x, y: x - y,
    '''*''': lambda x, y: x * y,
    '''/''': lambda x, y: x / y,
}



def    snake_case_(_UpperCamelCase  )							->			str:



  """simple docstring"""






  return c.isdigit()



def    snake_case_(_UpperCamelCase  )							->			str:



  """simple docstring"""






  _snake_case		=							[]

  # iterate over the string in reverse order
  for c in expression.split()[::-1]:
    # push operand to stack
    if is_operand(_UpperCamelCase  ):
      stack.append(int(_UpperCamelCase  )  )

    else:
      # pop values from stack can calculate the result
      # push the result onto the stack again
      _snake_case		=							stack.pop()
      _snake_case		=							stack.pop()
      stack.append(calc[c](_UpperCamelCase				, _UpperCamelCase  )  )

  return stack.pop()


# Driver code
if __name__ == "__main__":
 __A    	=			'''+ 9 * 2 6'''
 print(evaluate(test_expression))

 __A    	=			'''/ * 10 2 + 4 1 '''
 print(evaluate(test_expression))

