

from __future__ import annotations

from typing import Generic, TypeVar

__A    	=			TypeVar('''T''')



class 						lowercase_					(						Generic[T]  ):



      def __init__(    self   :       str    ,      A__   :       T	)					->  Union[str, Any]:
        _snake_case		=							data  # Assign data
        _snake_case		=							None  # Initialize next as null
        _snake_case		=							None  # Initialize prev as null



class 						lowercase_					(						Generic[T]  ):



      def __init__(    self   :       List[str]	)					->  None:
        _snake_case		=							None



      def 		UpperCamelCase_	(    self   :       List[str]    ,      A__   :       T	)					->  None:
        if self.head is None:
          _snake_case		=							Node(A__	)
        else:
          _snake_case		=							Node(A__	)
          _snake_case		=							new_node
          _snake_case		=							self.head
          _snake_case		=							None
          _snake_case		=							new_node



      def 		UpperCamelCase_	(    self   :       Tuple	)					->  T | None:
        if self.head is None:
          return None
        else:
          assert self.head is not None
          _snake_case		=							self.head.data
          _snake_case		=							self.head.next
          if self.head is not None:
            _snake_case		=							None
          return temp



      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  T | None:
        return self.head.data if self.head is not None else None



      def __len__(    self   :       Optional[int]	)					->  int:
        _snake_case		=							self.head
        _snake_case		=							0
        while temp is not None:
          count += 1
          _snake_case		=							temp.next
        return count



      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  bool:
        return self.head is None







      def 		UpperCamelCase_	(    self   :       Dict	)					->  None:
        print('''stack elements are:'''	)
        _snake_case		=							self.head
        while temp is not None:
          print(temp.data    ,      end='''->'''	)
          _snake_case		=							temp.next


# Code execution starts here
if __name__ == "__main__":
  # Start with the empty stack
  __A    	=			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())




from collections import namedtuple

__A    	=			namedtuple('''from_to''', '''from_ to''')

__A    	=			{
    '''atm''': from_to(1, 1),
    '''pascal''': from_to(0.000_0098, 10_13_25),
    '''bar''': from_to(0.98_6923, 1.0_1325),
    '''kilopascal''': from_to(0.0098_6923, 101.325),
    '''megapascal''': from_to(9.8_6923, 0.10_1325),
    '''psi''': from_to(0.06_8046, 14.6959),
    '''inHg''': from_to(0.033_4211, 29.9213),
    '''torr''': from_to(0.0013_1579, 7_60),
}



def    snake_case_(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )							->			float:



  """simple docstring"""






  if from_type not in PRESSURE_CONVERSION:
    raise ValueError(
        F"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
        + ''', '''.join(_UpperCamelCase  )  )
  if to_type not in PRESSURE_CONVERSION:
    raise ValueError(
        F"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
        + ''', '''.join(_UpperCamelCase  )  )
  return (
      value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
  )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

