


import operator as op


def 				lowerCamelCase__	(      a	:   str				)    ->	Union[str, Any]:





			"""simple docstring"""
			a__ :List[str]						  =    []
			a__ :Optional[Any]						  =    lambda a	,  a				: int(x / y				)  # noqa: E731 integer division operation
			a__ :int						  =    {
			    "^": 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(a				))				)

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

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

									stack.append(
									    str(opr[x](int(a				)	,  int(a				)				)				)				)  # 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(a				)	,  sep=" | "	,  )

			return int(stack[0]				)


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






import importlib
import os
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Optional, Union

import torch

from ..utils import BaseOutput


snake_case__			 =						'''scheduler_config.json'''


class 					lowerCAmelCase_ (       _a):
						lowerCamelCase_         =     1
						lowerCamelCase_         =     2
						lowerCamelCase_         =     3
						lowerCamelCase_         =     4
						lowerCamelCase_         =     5
						lowerCamelCase_         =     6
						lowerCamelCase_         =     7
						lowerCamelCase_         =     8
						lowerCamelCase_         =     9
						lowerCamelCase_         =     10
						lowerCamelCase_         =     11
						lowerCamelCase_         =     12
						lowerCamelCase_         =     13
						lowerCamelCase_         =     14






@dataclass
class 					lowerCAmelCase_ (       _a):
						lowerCamelCase_         =     42






class 					lowerCAmelCase_ :
						lowerCamelCase_         =     SCHEDULER_CONFIG_NAME
						lowerCamelCase_         =     []
						lowerCamelCase_         =     True




						@classmethod
						def  _snake_case					(	cls						:   Union[str, Any]   ,     __A						:   Dict[str, Any] = None   ,     __A						:   Optional[str] = None   ,     __A						:   Optional[int]=False   ,     **__A						:   Union[str, Any]   ,     )      ->List[Any]:






									"""simple docstring"""






									a__  ,  a__  ,  a__ :List[Any]						  =    cls.load_config(
									    pretrained_model_name_or_path=__A   ,     subfolder=__A   ,     return_unused_kwargs=__A   ,     return_commit_hash=__A   ,     **__A   ,     )
									return cls.from_config(__A   ,     return_unused_kwargs=__A   ,     **__A						)




						def  _snake_case					(	self						:   str   ,     __A						:   Union[str, os.PathLike]   ,     __A						:   bool = False   ,     **__A						:   Optional[Any]						)      ->str:






									"""simple docstring"""






									self.save_config(save_directory=__A   ,     push_to_hub=__A   ,     **__A						)




						@property
						def  _snake_case					(	self						:   List[Any]						)      ->Dict:






									"""simple docstring"""






									return self._get_compatibles()






						@classmethod
						def  _snake_case					(	cls						:   Dict						)      ->int:






									"""simple docstring"""






									a__ :Optional[int]						  =    list(set([cls.__name__] + cls._compatibles						)						)
									a__ :Union[str, Any]						  =    importlib.import_module(__name__.split("."						)[0]						)
									a__ :Optional[int]						  =    [
									    getattr(__A   ,     __A						) for c in compatible_classes_str if hasattr(__A   ,     __A						)
									]
									return compatible_classes


