






import operator as op



def  a__ (__lowercase							:List[Any]   )		-> Optional[int]:
				_A	:				Any   =      []
				_A	:				Union[str, Any]   =      lambda __lowercase					,  __lowercase   : int(x / y   )  # noqa: E731 integer division operation
				_A	:				Optional[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(__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	:				str   =      stack.pop()  # pop stack
												# output in tabular format
												print(''''''.rjust(8   )					,  ('''pop(''' + b + ''')''').ljust(12   )					,  ''','''.join(__lowercase   )					,  sep=''' | '''   )

												_A	:				Optional[int]   =      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__":
	_UpperCamelCase			:	Tuple								=input('\n\nEnter a Postfix Equation (space separated) = ').split(' ')
	print('\n\tResult = ', solve(Postfix))











def  a__ (__lowercase							:str					,  __lowercase							:str   )		-> float:

				def get_matched_characters(__lowercase							:str					,  __lowercase							:str   ) -> str:
								_A	:				Union[str, Any]   =      []
								_A	:				Dict   =      min(len(_stra   )					,  len(_stra   )   ) // 2
								for i, l in enumerate(_stra   ):
												_A	:				Tuple   =      int(max(0					,  i - limit   )   )
												_A	:				Union[str, Any]   =      int(min(i + limit + 1					,  len(_stra   )   )   )
												if l in _stra[left:right]:
																matched.append(__lowercase   )
																_A	:				List[Any]   =      f"""{_stra[0:_stra.index(__lowercase   )]} {_stra[_stra.index(__lowercase   ) + 1:]}"""

								return "".join(__lowercase   )

				# matching characters
				_A	:				str   =      get_matched_characters(__lowercase					,  __lowercase   )
				_A	:				Optional[Any]   =      get_matched_characters(__lowercase					,  __lowercase   )
				_A	:				Any   =      len(__lowercase   )

				# transposition
				_A	:				str   =      (
				    len([(ca, ca) for ca, ca in zip(__lowercase					,  __lowercase   ) if ca != ca]   ) // 2
				)

				if not match_count:
								_A	:				Optional[int]   =      0.0
				else:
								_A	:				str   =      (
								    1
								    / 3
								    * (
								        match_count / len(__lowercase   )
								        + match_count / len(__lowercase   )
								        + (match_count - transpositions) / match_count
								    )
								)

				# common prefix up to 4 characters
				_A	:				Any   =      0
				for ca, ca in zip(stra[:4]					,  stra[:4]   ):
								if ca == ca:
												prefix_len += 1
								else:
												break

				return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(jaro_winkler('hello', 'world'))



