



import operator as op



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			[]
	__lowercase		       =			lambda _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   : int(x / y   )  # noqa: E731 integer division operation
	__lowercase		       =			{
	    "^": op.pow,
	    "*": op.mul,
	    "/": div,
	    "+": op.add,
	    "-": op.sub,
	}  # operators & their respective operation

	# print table header
	print("Symbol".center(8   )  ,	"Action".center(1_2   )  ,	"Stack"  ,	sep=" | "   )
	print("-" * (3_0 + 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(1_2   )  ,	",".join(_SCREAMING_SNAKE_CASE   )  ,	sep=" | "   )
		else:
			__lowercase		       =			stack.pop()  # pop stack
			# output in tabular format
			print("".rjust(8   )  ,	("pop(" + b + ")").ljust(1_2   )  ,	",".join(_SCREAMING_SNAKE_CASE   )  ,	sep=" | "   )

			__lowercase		       =			stack.pop()  # pop stack
			# output in tabular format
			print("".rjust(8   )  ,	("pop(" + a + ")").ljust(1_2   )  ,	",".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(1_2   )  ,	",".join(_SCREAMING_SNAKE_CASE   )  ,	sep=" | "  ,	)

	return int(stack[0]   )


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








def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):

	# bit count represents no. of bits in the gray code
	if bit_count < 0:
		raise ValueError("The given input must be positive"   )

	# get the generated string sequence
	__lowercase		       =			gray_code_sequence_string(_SCREAMING_SNAKE_CASE   )
	#
	# convert them to integers
	for i in range(len(_SCREAMING_SNAKE_CASE   )   ):
		__lowercase		       =			int(sequence[i]  ,	2   )

	return sequence



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):

	# The approach is a recursive one
	# Base case achieved when either n = 0 or n=1
	if bit_count == 0:
		return ["0"]

	if bit_count == 1:
		return ["0", "1"]

	__lowercase		       =			1 << bit_count  # defines the length of the sequence
	# 1<< n is equivalent to 2^n

	# recursive answer will generate answer for n-1 bits
	__lowercase		       =			gray_code_sequence_string(bit_count - 1   )

	__lowercase		       =			[]

	# append 0 to first half of the smaller sequence generated
	for i in range(seq_len // 2   ):
		__lowercase		       =			"0" + smaller_sequence[i]
		sequence.append(_SCREAMING_SNAKE_CASE   )

	# append 1 to second half ... start from the end of the list
	for i in reversed(range(seq_len // 2   )   ):
		__lowercase		       =			"1" + smaller_sequence[i]
		sequence.append(_SCREAMING_SNAKE_CASE   )

	return sequence


if __name__ == "__main__":
	import doctest

	doctest.testmod()



