






'''simple docstring'''







def  SCREAMING_SNAKE_CASE_       (UpperCamelCase      )      ->       list:

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

							lowerCamelCase__					:	Union[str, Any]         =       []

							def generate(UpperCamelCase				,			UpperCamelCase      ):
														lowerCamelCase__					:	List[str]         =       [0] * n
														res.append(tuple(UpperCamelCase      )      )

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

							generate(len(UpperCamelCase      )				,			UpperCamelCase      )
							return res


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


from torch import nn





class 		_lowercase						(					nn.Module       ):

 def __init__( self	:							Any   ,      snake_case	:							Dict   ,      snake_case	:							Union[str, Any]			)   ->						Dict:

  """simple docstring"""





  super().__init__()
  UpperCamelCase_					:						List[Any] =					class_size
  UpperCamelCase_					:						List[Any] =					embed_size
  # self.mlp1 = nn.Linear(embed_size, embed_size)
  # self.mlp2 = (nn.Linear(embed_size, class_size))
  UpperCamelCase_					:						int =					nn.Linear(snake_case   ,      snake_case			)


 def 						SCREAMING_SNAKE_CASE__   ( self	:							List[str]   ,      snake_case	:							Any			)   ->						str:

  """simple docstring"""





  UpperCamelCase_					:						Dict =					self.mlp(snake_case			)
  return logits



