


import itertools
import string
from collections.abc import Generator, Iterable







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				Generator[tuple[str, ...], None, None]:
  snake_case__						= iter(__lowerCAmelCase				)
  while True:
    snake_case__						= tuple(itertools.islice(__lowerCAmelCase							,   __lowerCAmelCase				)				)
    if not chunk:
      return
    yield chunk







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase				)    ->				str:
  snake_case__						= ''''''.join([c.upper() for c in dirty if c in string.ascii_letters]				)
  snake_case__						= ''''''

  if len(__lowerCAmelCase				) < 2:
    return dirty

  for i in range(len(__lowerCAmelCase				) - 1				):
    clean += dirty[i]

    if dirty[i] == dirty[i + 1]:
      clean += "X"

  clean += dirty[-1]

  if len(__lowerCAmelCase				) & 1:
    clean += "X"

  return clean







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase				)    ->				list[str]:
  # I and J are used interchangeably to allow
  # us to use a 5x5 table (25 letters)
  snake_case__						= '''ABCDEFGHIKLMNOPQRSTUVWXYZ'''
  # we're using a list instead of a '2d' array because it makes the math
  # for setting up the table and doing the actual encoding/decoding simpler
  snake_case__						= []

  # copy key chars into the table if they are in `alphabet` ignoring duplicates
  for char in key.upper():
    if char not in table and char in alphabet:
      table.append(__lowerCAmelCase				)

    # fill the rest of the table in with the remaining alphabet chars
  for char in alphabet:
    if char not in table:
      table.append(__lowerCAmelCase				)

  return table







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				str:
  snake_case__						= generate_table(__lowerCAmelCase				)
  snake_case__						= prepare_input(__lowerCAmelCase				)
  snake_case__						= ''''''

  # https://en.wikipedia.org/wiki/Playfair_cipher#Description
  for chara, chara in chunker(__lowerCAmelCase							,   2				):
    snake_case__				,				snake_case__						= divmod(table.index(__lowerCAmelCase				)							,   5				)
    snake_case__				,				snake_case__						= divmod(table.index(__lowerCAmelCase				)							,   5				)

    if rowa == rowa:
      ciphertext += table[rowa * 5 + (cola + 1) % 5]
      ciphertext += table[rowa * 5 + (cola + 1) % 5]
    elif cola == cola:
      ciphertext += table[((rowa + 1) % 5) * 5 + cola]
      ciphertext += table[((rowa + 1) % 5) * 5 + cola]
    else:  # rectangle
      ciphertext += table[rowa * 5 + cola]
      ciphertext += table[rowa * 5 + cola]

  return ciphertext







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				str:
  snake_case__						= generate_table(__lowerCAmelCase				)
  snake_case__						= ''''''

  # https://en.wikipedia.org/wiki/Playfair_cipher#Description
  for chara, chara in chunker(__lowerCAmelCase							,   2				):
    snake_case__				,				snake_case__						= divmod(table.index(__lowerCAmelCase				)							,   5				)
    snake_case__				,				snake_case__						= divmod(table.index(__lowerCAmelCase				)							,   5				)

    if rowa == rowa:
      plaintext += table[rowa * 5 + (cola - 1) % 5]
      plaintext += table[rowa * 5 + (cola - 1) % 5]
    elif cola == cola:
      plaintext += table[((rowa - 1) % 5) * 5 + cola]
      plaintext += table[((rowa - 1) % 5) * 5 + cola]
    else:  # rectangle
      plaintext += table[rowa * 5 + cola]
      plaintext += table[rowa * 5 + cola]

  return plaintext





def 			lowerCAmelCase__					(     a__:						Optional[int]			)    ->						Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase											=     len(a__			)
							for i in range(length - 1			):
														_UpperCAmelCase											=     i
														for k in range(i + 1     ,    a__			):
																					if collection[k] < collection[least]:
																												_UpperCAmelCase											=     k
														if least != i:
																					_UpperCAmelCase						,			_UpperCAmelCase											=     (collection[i], collection[least])
							return collection


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