


def  _a			(						__UpperCamelCase ):

     if len(__UpperCamelCase ) <= 1:
          return [tuple(__UpperCamelCase )]

     a_    :     List[Any]										=    []

     def generate(__UpperCamelCase  ,  __UpperCamelCase ):
          a_    :     Optional[Any]										=    [0] * n
          res.append(tuple(__UpperCamelCase ) )

          a_    :     Optional[Any]										=    0
          while i < n:
               if c[i] < i:
                    if i % 2 == 0:
                         a_			,			a_    :     Optional[int]										=    arr[i], arr[0]
                    else:
                         a_			,			a_    :     Dict										=    arr[i], arr[c[i]]
                    res.append(tuple(__UpperCamelCase ) )
                    c[i] += 1
                    a_    :     List[str]										=    0
               else:
                    a_    :     List[Any]										=    0
                    i += 1

     generate(len(__UpperCamelCase )  ,  __UpperCamelCase )
     return res


if __name__ == "__main__":
       __lowerCamelCase        =     input('''Enter numbers separated by a comma:\n''').strip()
       __lowerCamelCase        =     [int(item) for item in user_input.split(''',''')]
       print(heaps(arr))







import numpy as np

__lowerCamelCase        =     [
    ['''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__	:

       def __init__(   self      :     Union[str, Any]    ):
            a_    :     List[Any]										=    np.array(lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Union[str, Any]      ,							lowerCamelCase_      :     str    ):
            a_			,			a_    :     Optional[int]										=    np.where(letter == self.SQUARE    )
            a_    :     Union[str, Any]										=    np.concatenate([indexa + 1, indexa + 1]    )
            return indexes

       def 						UpperCAmelCase(   self      :     Tuple      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     int    ):
            a_    :     str										=    self.SQUARE[indexa - 1, indexa - 1]
            return letter

       def 						UpperCAmelCase(   self      :     Optional[Any]      ,							lowerCamelCase_      :     str    ):
            a_    :     List[str]										=    message.lower()
            a_    :     str										=    message.replace(""" """      ,							""""""    )
            a_    :     Union[str, Any]										=    message.replace("""j"""      ,							"""i"""    )

            a_    :     Optional[Any]										=    np.empty((2, len(lowerCamelCase_    ))    )
            for letter_index in range(len(lowerCamelCase_    )    ):
                 a_    :     int										=    self.letter_to_numbers(message[letter_index]    )

                 a_    :     str										=    numbers[0]
                 a_    :     int										=    numbers[1]

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

            return encoded_message

       def 						UpperCAmelCase(   self      :     Tuple      ,							lowerCamelCase_      :     str    ):
            a_    :     Optional[Any]										=    message.lower()
            message.replace(""" """      ,							""""""    )
            a_    :     int										=    np.empty(2 * len(lowerCamelCase_    )    )
            for letter_index in range(len(lowerCamelCase_    )    ):
                 a_    :     str										=    self.letter_to_numbers(message[letter_index]    )
                 a_    :     Optional[int]										=    numbers[0]
                 a_    :     Optional[Any]										=    numbers[1]

            a_    :     Tuple										=    first_step.reshape((2, len(lowerCamelCase_    ))    )
            a_    :     Optional[int]										=    """"""
            for numbers_index in range(len(lowerCamelCase_    )    ):
                 a_    :     Dict										=    int(second_step[0, numbers_index]    )
                 a_    :     Tuple										=    int(second_step[1, numbers_index]    )
                 a_    :     Tuple										=    self.numbers_to_letter(lowerCamelCase_      ,							lowerCamelCase_    )
                 a_    :     Union[str, Any]										=    decoded_message + letter

            return decoded_message



