


import numpy as np

_snake_case	:						str         =							[
    ["a", "b", "c", "d", "e"],
    ["f", "g", "h", "i", "k"],
    ["l", "m", "n", "o", "p"],
    ["q", "r", "s", "t", "u"],
    ["v", "w", "x", "y", "z"],
]

class 							a						:




							"""simple docstring"""


							def __init__(				self			:    Optional[int]							)      ->       None:
														__snake_case						:     Optional[int]									=  np.array(lowerCamelCase							)

							def        __snake_case   (				self			:    Union[str, Any]       ,      lowerCamelCase			:    str							)      ->       np.ndarray:
														__snake_case					,     __snake_case						:     Optional[int]									=  np.where(letter == self.SQUARE							)
														__snake_case						:     Union[str, Any]									=  np.concatenate([indexa + 1, indexa + 1]							)
														return indexes

							def        __snake_case   (				self			:    Union[str, Any]       ,      lowerCamelCase			:    int       ,      lowerCamelCase			:    int							)      ->       str:
														__snake_case						:     Optional[int]									=  self.SQUARE[indexa - 1, indexa - 1]
														return letter

							def        __snake_case   (				self			:    Union[str, Any]       ,      lowerCamelCase			:    str							)      ->       str:
														__snake_case						:     Dict									=  message.lower()
														__snake_case						:     List[Any]									=  message.replace(" "       ,      ""							)
														__snake_case						:     List[Any]									=  message.replace("j"       ,      "i"							)

														__snake_case						:     Optional[Any]									=  np.empty((2, len(lowerCamelCase							))							)
														for letter_index in range(len(lowerCamelCase							)							):
																					__snake_case						:     List[Any]									=  self.letter_to_numbers(message[letter_index]							)

																					__snake_case						:     Any									=  numbers[0]
																					__snake_case						:     Dict									=  numbers[1]

														__snake_case						:     Optional[Any]									=  first_step.reshape(2 * len(lowerCamelCase							)							)
														__snake_case						:     str									=  ""
														for numbers_index in range(len(lowerCamelCase							)							):
																					__snake_case						:     str									=  int(second_step[numbers_index * 2]							)
																					__snake_case						:     List[Any]									=  int(second_step[(numbers_index * 2) + 1]							)
																					__snake_case						:     Optional[Any]									=  self.numbers_to_letter(lowerCamelCase       ,      lowerCamelCase							)
																					__snake_case						:     Union[str, Any]									=  encoded_message + letter

														return encoded_message






							def        __snake_case   (				self			:    Any       ,      lowerCamelCase			:    str							)      ->       str:
														__snake_case						:     Tuple									=  message.lower()
														message.replace(" "       ,      ""							)
														__snake_case						:     Dict									=  np.empty(2 * len(lowerCamelCase							)							)
														for letter_index in range(len(lowerCamelCase							)							):
																					__snake_case						:     str									=  self.letter_to_numbers(message[letter_index]							)
																					__snake_case						:     Dict									=  numbers[0]
																					__snake_case						:     Union[str, Any]									=  numbers[1]

														__snake_case						:     int									=  first_step.reshape((2, len(lowerCamelCase							))							)
														__snake_case						:     List[Any]									=  ""
														for numbers_index in range(len(lowerCamelCase							)							):
																					__snake_case						:     List[Any]									=  int(second_step[0, numbers_index]							)
																					__snake_case						:     Optional[Any]									=  int(second_step[1, numbers_index]							)
																					__snake_case						:     str									=  self.numbers_to_letter(lowerCamelCase       ,      lowerCamelCase							)
																					__snake_case						:     List[Any]									=  decoded_message + letter

														return decoded_message







'''simple docstring'''

import operator as op


def 						__magic_name__       (      __UpperCAmelCase      )						->   Dict:

					'''simple docstring'''

					snake_case_		     =							[]
					snake_case_		     =							lambda __UpperCAmelCase, __UpperCAmelCase      : int(x / y      )  # noqa: E731 integer division operation
					snake_case_		     =							{
					    '''^''': 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:
															snake_case_		     =							stack.pop()  # pop stack
															# output in tabular format
															print(''''''.rjust(8      ), ('''pop(''' + b + ''')''').ljust(12      ), ''','''.join(__UpperCAmelCase      ), sep=''' | '''      )

															snake_case_		     =							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__":
							a    :							Any										=    input('\n\nEnter a Postfix Equation (space separated) = ').split(' ')
							print('\n\tResult = ', solve(Postfix))

