




import operator as op

def      A      (      _SCREAMING_SNAKE_CASE    )	-> Union[str, Any]:
       lowerCamelCase   :      Any			 =					[]
       lowerCamelCase   :      List[str]			 =					lambda _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    : int(x / y    )  # noqa: E731 integer division operation
       lowerCamelCase   :      Tuple			 =					{
           "^": op.pow,
           "*": op.mul,
           "/": div,
           "+": op.add,
           "-": op.sub,
       }  # operators & their respective operation

       # print table header
       print("Symbol".center(8    ) ,"Action".center(12    ) ,"Stack" ,sep=" | "    )
       print("-" * (30 + len(_SCREAMING_SNAKE_CASE    ))    )

       for x in post_fix:
              if x.isdigit():  # if x in digit
                     stack.append(_SCREAMING_SNAKE_CASE    )  # append x to stack
                     # output in tabular format
                     print(x.rjust(8    ) ,("push(" + x + ")").ljust(12    ) ,",".join(_SCREAMING_SNAKE_CASE    ) ,sep=" | "    )
              else:
                     lowerCamelCase   :      Optional[int]			 =					stack.pop()  # pop stack
                     # output in tabular format
                     print("".rjust(8    ) ,("pop(" + b + ")").ljust(12    ) ,",".join(_SCREAMING_SNAKE_CASE    ) ,sep=" | "    )

                     lowerCamelCase   :      int			 =					stack.pop()  # pop stack
                     # output in tabular format
                     print("".rjust(8    ) ,("pop(" + a + ")").ljust(12    ) ,",".join(_SCREAMING_SNAKE_CASE    ) ,sep=" | "    )

                     stack.append(
                         str(opr[x](int(_SCREAMING_SNAKE_CASE    ) ,int(_SCREAMING_SNAKE_CASE    )    )    )    )  # evaluate the 2 values popped from stack & push result to stack
                     # output in tabular format
                     print(
                         x.rjust(8    ) ,("push(" + a + x + b + ")").ljust(12    ) ,",".join(_SCREAMING_SNAKE_CASE    ) ,sep=" | " ,)

       return int(stack[0]    )


if __name__ == "__main__":
       SCREAMING_SNAKE_CASE__       :      Tuple  =   input('\n\nEnter a Postfix Equation (space separated) = ').split(' ')
       print('\n\tResult = ', solve(Postfix))













"""simple docstring"""
from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable


lowerCamelCase_								=		{"configuration_dpt": ["DPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPTConfig"]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_								=		["DPTFeatureExtractor"]
  lowerCamelCase_								=		["DPTImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_								=		[
      "DPT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "DPTForDepthEstimation",
      "DPTForSemanticSegmentation",
      "DPTModel",
      "DPTPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_dpt import DPTFeatureExtractor
    from .image_processing_dpt import DPTImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dpt import (
        DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPTForDepthEstimation,
        DPTForSemanticSegmentation,
        DPTModel,
        DPTPreTrainedModel,
    )


else:
  import sys

  lowerCamelCase_								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)