

"""simple docstring"""



import operator as op





def        _snake_case   (			UpperCAmelCase_     :    Optional[Any]	):
     A__								=     []
     A__								=     lambda UpperCAmelCase_    ,      UpperCAmelCase_	: int(x / y	)  # noqa: E731 integer division operation
     A__								=     {
         """^""": 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(UpperCAmelCase__	))	)

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

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

               stack.append(
                   str(opr[x](int(UpperCAmelCase__	)    ,      int(UpperCAmelCase__	)	)	)	)  # 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(UpperCAmelCase__	)    ,      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'''




_lowercase						: str						=						tuple[float, float, float]
_lowercase						: List[Any]						=						tuple[float, float, float]




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad )			->      Vectorad:
							lowercase_					:			List[str]										=       end_pointa[0] - end_pointa[0]
							lowercase_					:			Union[str, Any]										=       end_pointa[1] - end_pointa[1]
							lowercase_					:			List[Any]										=       end_pointa[2] - end_pointa[2]
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					Vectorad )			->      Vectorad:
							lowercase_					:			List[Any]										=       ab[1] * ac[2] - ab[2] * ac[1]  # *i
							lowercase_					:			Union[str, Any]										=       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
							lowercase_					:			List[str]										=       ab[0] * ac[1] - ab[1] * ac[0]  # *k
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					int )			->      bool:
							return tuple(round(UpperCAmelCase__      ,      UpperCAmelCase__ ) for x in vector ) == (0, 0, 0)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					int = 10 )			->      bool:
							lowercase_					:			Dict										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							lowercase_					:			Optional[int]										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase__      ,      UpperCAmelCase__ )      ,      UpperCAmelCase__ )





