

'''simple docstring'''
def       _A	(			snake_case  )    ->			int:
   _lowercase    :   Tuple      =     len(snake_case  )
   if n in (0, 1):
      return 0
   return sum(query * (n - i - 1) for i, query in enumerate(sorted(snake_case  )  )  )


if __name__ == "__main__":
    import doctest

    doctest.testmod()









'''simple docstring'''
from __future__ import annotations

from typing import Generic, TypeVar

_snake_case     						=						TypeVar('T')


class      a__						(							Generic[T]						):


   def __init__(				self    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Any      =     data  # Assign data
      _lowercase    :   Node[T] | None      =     None  # Initialize next as null
      _lowercase    :   Node[T] | None      =     None  # Initialize prev as null




class      a__						(							Generic[T]						):


   def __init__(				self						):





      """simple docstring"""





      _lowercase    :   Node[T] | None      =     None


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase						):





      """simple docstring"""





      if self.head is None:
         _lowercase    :   Optional[int]      =     Node(_UpperCamelCase						)
      else:
         _lowercase    :   str      =     Node(_UpperCamelCase						)
         _lowercase    :   Optional[Any]      =     new_node
         _lowercase    :   List[str]      =     self.head
         _lowercase    :   Tuple      =     None
         _lowercase    :   Tuple      =     new_node


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      if self.head is None:
         return None
      else:
         assert self.head is not None
         _lowercase    :   str      =     self.head.data
         _lowercase    :   Optional[Any]      =     self.head.next
         if self.head is not None:
            _lowercase    :   Optional[int]      =     None
         return temp


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      return self.head.data if self.head is not None else None


   def __len__(				self						):





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     self.head
      _lowercase    :   Tuple      =     0
      while temp is not None:
         count += 1
         _lowercase    :   Tuple      =     temp.next
      return count


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      return self.head is None






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      print("stack elements are:"						)
      _lowercase    :   str      =     self.head
      while temp is not None:
         print(temp.data    ,       end="->"						)
         _lowercase    :   Any      =     temp.next


# Code execution starts here
if __name__ == "__main__":
    # Start with the empty stack
    _snake_case     						=						Stack()

    # Insert 4 at the beginning. So stack becomes 4->None
    print('Stack operations using Doubly LinkedList')
    stack.push(4)

    # Insert 5 at the beginning. So stack becomes 4->5->None
    stack.push(5)

    # Insert 6 at the beginning. So stack becomes 4->5->6->None
    stack.push(6)

    # Insert 7 at the beginning. So stack becomes 4->5->6->7->None
    stack.push(7)

    # Print the stack
    stack.print_stack()

    # Print the top element
    print('\nTop element is ', stack.top())

    # Print the stack size
    print('Size of the stack is ', len(stack))

    # pop the top element
    stack.pop()

    # pop the top element
    stack.pop()

    # two elements have now been popped off
    stack.print_stack()

    # Print True if the stack is empty else False
    print('\nstack is empty:', stack.is_empty())






