

import operator as op

def 						UpperCamelCase					(lowercase_: Optional[Any]					)     ->      List[Any]:
	A__							:    Dict        =		[]
	A__							:    str        =		lambda lowercase_    ,      lowercase_					: int(x / y					)  # noqa: E731 integer division operation
	A__							:    Union[str, Any]        =		{
	    """^""": 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(lowercase_					))					)

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

			A__							:    Optional[Any]        =		stack.pop()  # pop stack
			# output in tabular format
			print("""""".rjust(8					)    ,      ("""pop(""" + a + """)""").ljust(12					)    ,      """,""".join(lowercase_					)    ,      sep=""" | """					)

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

	return int(stack[0]					)


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






from typing import TYPE_CHECKING

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


A_       : List[str]         =			{
    'configuration_gpt_neox_japanese': ['GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTNeoXJapaneseConfig'],
    'tokenization_gpt_neox_japanese': ['GPTNeoXJapaneseTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A_       : Optional[int]         =			[
	    'GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GPTNeoXJapaneseForCausalLM',
	    'GPTNeoXJapaneseLayer',
	    'GPTNeoXJapaneseModel',
	    'GPTNeoXJapanesePreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_gpt_neox_japanese import GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXJapaneseConfig
	from .tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gpt_neox_japanese import (
		    GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTNeoXJapaneseForCausalLM,
		    GPTNeoXJapaneseLayer,
		    GPTNeoXJapaneseModel,
		    GPTNeoXJapanesePreTrainedModel,
		)


else:
	import sys

	A_       : Any         =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



