


"""simple docstring"""





def      _snake_case						(						_snake_case				:			list			):

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

      lowerCAmelCase					:	Optional[Any]       =   []

      def generate(_snake_case				:			int ,   _snake_case				:			list			):
            lowerCAmelCase					:	Dict       =   [0] * n
            res.append(tuple(_snake_case			)			)

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

      generate(len(_snake_case			) ,   _snake_case			)
      return res


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






"""simple docstring"""





from torch import nn



class 		snake_case_(       nn.Module			):






     def __init__(	self  :					int					,				UpperCamelCase_  :					int					,				UpperCamelCase_  :					int				):
           super().__init__()
           lowerCAmelCase					:	str       =   class_size
           lowerCAmelCase					:	Dict       =   embed_size
           # self.mlp1 = nn.Linear(embed_size, embed_size)
           # self.mlp2 = (nn.Linear(embed_size, class_size))
           lowerCAmelCase					:	Any       =   nn.Linear(UpperCamelCase_					,				UpperCamelCase_				)






     def      lowerCamelCase__     (	self  :					List[Any]					,				UpperCamelCase_  :					Tuple				):
           # hidden_state = nn.functional.relu(self.mlp1(hidden_state))
           # hidden_state = self.mlp2(hidden_state)
           lowerCAmelCase					:	int       =   self.mlp(UpperCamelCase_				)
           return logits


