






import operator as op

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  Tuple					)		->			int:






	"""simple docstring"""



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

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

			UpperCamelCase     :Union[str, Any]          =	stack.pop()  # pop stack
			# output in tabular format
			print("""""".rjust(8					)	,			("""pop(""" + a + """)""").ljust(12					)	,			""",""".join(__magic_name__					)	,			sep=""" | """					)

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

	return int(stack[0]					)


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


from unittest import TestCase

from datasets import Dataset
from minhash_deduplication import deduplicate_dataset, make_duplicate_clusters


def       A       (					)   ->  Union[str, Any]:
		'''simple docstring'''

		UpperCamelCase		=     {
		    'repo_name': ['test_repo1', 'test_repo2', 'test_repo3'],
		    'path': ['test_1.py', 'test_2.py', 'unit_test.py'],
		    'content': ['a ' * 20, 'a ' * 30, 'b ' * 7],
		}
		UpperCamelCase		=     Dataset.from_dict(lowercase )
		return dataset


class 				lowercase					(		_SCREAMING_SNAKE_CASE   ):



		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     get_dataset()
				UpperCamelCase		=     make_duplicate_clusters(A_				,      0.85       )
				self.assertEqual(len(duplicate_clusters[0]       )				,      2       )



		def __UpperCamelCase ( self       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     get_dataset()
				UpperCamelCase	,  UpperCamelCase		=     deduplicate_dataset(A_       )
				self.assertEqual(len(A_       )				,      2       )
				print(A_       )
				self.assertEqual(duplicate_clusters[0][0]['copies']				,      2       )
				self.assertEqual(duplicate_clusters[0][0]['is_extreme']				,      A_       )
