'''simple docstring'''


def  _lowerCamelCase   (				lowerCamelCase_ :							Any       ):



     """simple docstring"""





     UpperCAmelCase_							:       Optional[Any]       =				[]
     UpperCAmelCase_							:       str       =				[]
     UpperCAmelCase_							:       Union[str, Any]       =				{
         '^': 3,
         '*': 2,
         '/': 2,
         '%': 2,
         '+': 1,
         '-': 1,
     }  # Priority of each operator
     UpperCAmelCase_							:       int       =				len(lowerCamelCase_       ) if (len(lowerCamelCase_       ) > 7) else 7

     # Print table header for output
     print(
         'Symbol'.center(8       )     ,					'Stack'.center(lowerCamelCase_       )     ,					'Postfix'.center(lowerCamelCase_       )     ,					sep=' | '     ,					)
     print('-' * (print_width * 3 + 7)       )

     for x in infix:
          if x.isalpha() or x.isdigit():
               post_fix.append(lowerCamelCase_       )  # if x is Alphabet / Digit, add it to Postfix
          elif x == "(":
               stack.append(lowerCamelCase_       )  # if x is "(" push to Stack
          elif x == ")":  # if x is ")" pop stack until "(" is encountered
               while stack[-1] != "(":
                    post_fix.append(stack.pop()       )  # Pop stack & add the content to Postfix
               stack.pop()
          else:
               if len(lowerCamelCase_       ) == 0:
                    stack.append(lowerCamelCase_       )  # If stack is empty, push x to stack
               else:  # while priority of x is not > priority of element in the stack
                    while len(lowerCamelCase_       ) > 0 and priority[x] <= priority[stack[-1]]:
                         post_fix.append(stack.pop()       )  # pop stack & add to Postfix
                    stack.append(lowerCamelCase_       )  # push x to stack

          print(
              x.center(8       )     ,					(''.join(lowerCamelCase_       )).ljust(lowerCamelCase_       )     ,					(''.join(lowerCamelCase_       )).ljust(lowerCamelCase_       )     ,					sep=' | '     ,					)  # Output in tabular format

     while len(lowerCamelCase_       ) > 0:  # while stack is not empty
          post_fix.append(stack.pop()       )  # pop stack & add to Postfix
          print(
              ' '.center(8       )     ,					(''.join(lowerCamelCase_       )).ljust(lowerCamelCase_       )     ,					(''.join(lowerCamelCase_       )).ljust(lowerCamelCase_       )     ,					sep=' | '     ,					)  # Output in tabular format

     return "".join(lowerCamelCase_       )  # return Postfix as str


def  _lowerCamelCase   (				lowerCamelCase_ :							int       ):



     """simple docstring"""





     UpperCAmelCase_							:       Union[str, Any]       =				list(infix[::-1]       )  # reverse the infix equation

     for i in range(len(lowerCamelCase_       )       ):
          if infix[i] == "(":
               UpperCAmelCase_							:       Tuple       =				')'  # change "(" to ")"
          elif infix[i] == ")":
               UpperCAmelCase_							:       Union[str, Any]       =				'('  # change ")" to "("

     return (infix_2_postfix(''.join(lowerCamelCase_       )       ))[
         ::-1
     ]  # call infix_2_postfix on Infix, return reverse of Postfix


if __name__ == "__main__":
 snake_case__					:      str				      =  input('''\nEnter an Infix Equation = ''')  # Input an Infix equation
 snake_case__					:      Any				      =  ''''''.join(Infix.split())  # Remove spaces from the input
 print('''\n\t''', Infix, '''(Infix) -> ''', infix_2_prefix(Infix), '''(Prefix)''')







'''simple docstring'''


snake_case__					:      Optional[Any]				      =  tuple[float, float, float]
snake_case__					:      Tuple				      =  tuple[float, float, float]


def  _lowerCamelCase   (				lowerCamelCase_ :							Pointad     ,					lowerCamelCase_ :							Pointad       ):



     """simple docstring"""





     UpperCAmelCase_							:       Any       =				end_pointa[0] - end_pointa[0]
     UpperCAmelCase_							:       Optional[Any]       =				end_pointa[1] - end_pointa[1]
     UpperCAmelCase_							:       Any       =				end_pointa[2] - end_pointa[2]
     return (x, y, z)


def  _lowerCamelCase   (				lowerCamelCase_ :							Vectorad     ,					lowerCamelCase_ :							Vectorad       ):



     """simple docstring"""





     UpperCAmelCase_							:       Optional[Any]       =				ab[1] * ac[2] - ab[2] * ac[1]  # *i
     UpperCAmelCase_							:       Optional[Any]       =				(ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
     UpperCAmelCase_							:       Dict       =				ab[0] * ac[1] - ab[1] * ac[0]  # *k
     return (x, y, z)


def  _lowerCamelCase   (				lowerCamelCase_ :							Vectorad     ,					lowerCamelCase_ :							int       ):



     """simple docstring"""





     return tuple(round(lowerCamelCase_     ,					lowerCamelCase_       ) for x in vector       ) == (0, 0, 0)





def  _lowerCamelCase   (				lowerCamelCase_ :							Pointad     ,					lowerCamelCase_ :							Pointad     ,					lowerCamelCase_ :							Pointad     ,					lowerCamelCase_ :							int = 10       ):



     """simple docstring"""





     UpperCAmelCase_							:       List[str]       =				create_vector(lowerCamelCase_     ,					lowerCamelCase_       )
     UpperCAmelCase_							:       List[Any]       =				create_vector(lowerCamelCase_     ,					lowerCamelCase_       )
     return is_zero_vector(get_ad_vectors_cross(lowerCamelCase_     ,					lowerCamelCase_       )     ,					lowerCamelCase_       )






