
def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    list[list]:
       lowercase							:     Dict       	=      current_set.copy()
       for row_index, row in enumerate(SCREAMING_SNAKE_CASE__				):
              lowercase							:     Tuple       	=      row[0]
              for column_index, column in enumerate(SCREAMING_SNAKE_CASE__				):
                     if magnitude == 0:
                            lowercase							:     Union[str, Any]       	=      column
                            continue
                     lowercase							:     List[Any]       	=      column / magnitude
    # Subtract to cancel term
       lowercase							:     Tuple       	=      current_set[0]
       lowercase							:     Tuple       	=      [first_row]
       lowercase							:     Union[str, Any]       	=      current_set[1::]
       for row in current_set:
              lowercase							:     Any       	=      []
              # If first term is 0, it is already in form we want, so we preserve it
              if row[0] == 0:
                     final_set.append(SCREAMING_SNAKE_CASE__				)
                     continue
              for column_index in range(len(SCREAMING_SNAKE_CASE__				)				):
                     temp_row.append(first_row[column_index] - row[column_index]				)
              final_set.append(SCREAMING_SNAKE_CASE__				)
       # Create next recursion iteration set
       if len(final_set[0]				) != 3:
              lowercase							:     List[str]       	=      final_set[0]
              lowercase							:     Dict       	=      []
              lowercase							:     str       	=      []
              for row in final_set[1::]:
                     current_first_column.append(row[0]				)
                     next_iteration.append(row[1::]				)
              lowercase							:     Dict       	=      simplify(SCREAMING_SNAKE_CASE__				)
              for i in range(len(SCREAMING_SNAKE_CASE__				)				):
                     resultant[i].insert(0					,	current_first_column[i]				)
              resultant.insert(0					,	SCREAMING_SNAKE_CASE__				)
              lowercase							:     Any       	=      resultant
       return final_set







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    list:
       if len(SCREAMING_SNAKE_CASE__				) == 0:
              raise IndexError("""solve_simultaneous() requires n lists of length n+1"""				)
       lowercase							:     str       	=      len(SCREAMING_SNAKE_CASE__				) + 1
       if any(len(SCREAMING_SNAKE_CASE__				) != _length for item in equations				):
              raise IndexError("""solve_simultaneous() requires n lists of length n+1"""				)
       for row in equations:
              if any(not isinstance(SCREAMING_SNAKE_CASE__					,	(int, float)				) for column in row				):
                     raise ValueError("""solve_simultaneous() requires lists of integers"""				)
       if len(SCREAMING_SNAKE_CASE__				) == 1:
              return [equations[0][-1] / equations[0][0]]
       lowercase							:     str       	=      equations.copy()
       if any(0 in row for row in data_set				):
              lowercase							:     Dict       	=      data_set.copy()
              lowercase							:     int       	=      []
              for row_index, row in enumerate(SCREAMING_SNAKE_CASE__				):
                     if 0 not in row:
                            lowercase							:     Tuple       	=      data_set.pop(SCREAMING_SNAKE_CASE__				)
                            break
              if not full_row:
                     raise ValueError("""solve_simultaneous() requires at least 1 full equation"""				)
              data_set.insert(0					,	SCREAMING_SNAKE_CASE__				)
       lowercase							:     Any       	=      data_set.copy()
       lowercase							:     List[str]       	=      simplify(SCREAMING_SNAKE_CASE__				)
       lowercase							:     int       	=      simplified[::-1]
       lowercase							:     list       	=      []
       for row in simplified:
              lowercase							:     List[Any]       	=      row[-1]
              if not solutions:
                     if row[-2] == 0:
                            solutions.append(0				)
                            continue
                     solutions.append(current_solution / row[-2]				)
                     continue
              lowercase							:     int       	=      row.copy()[: len(SCREAMING_SNAKE_CASE__				) - 1 :]
              while temp_row[0] == 0:
                     temp_row.pop(0				)
              if len(SCREAMING_SNAKE_CASE__				) == 0:
                     solutions.append(0				)
                     continue
              lowercase							:     Optional[Any]       	=      temp_row[1::]
              lowercase							:     Dict       	=      temp_row[::-1]
              for column_index, column in enumerate(SCREAMING_SNAKE_CASE__				):
                     current_solution -= column * solutions[column_index]
              solutions.append(SCREAMING_SNAKE_CASE__				)
       lowercase							:     Any       	=      []
       for item in solutions:
              final.append(float(round(SCREAMING_SNAKE_CASE__					,	5				)				)				)
       return final[::-1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  lowercase  :					Any						    =							[
      [2, 1, 1, 1, 1, 4],
      [1, 2, 1, 1, 1, 5],
      [1, 1, 2, 1, 1, 6],
      [1, 1, 1, 2, 1, 7],
      [1, 1, 1, 1, 2, 8],
  ]
  print(solve_simultaneous(eq))
  print(solve_simultaneous([[4, 2]]))




def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

  for i in range(len(SCREAMING_SNAKE_CASE_	) - 1      ,						0      ,						-1	):
    lowerCamelCase :					Tuple    =				False

    for j in range(SCREAMING_SNAKE_CASE_      ,						0      ,						-1	):
      if unsorted[j] < unsorted[j - 1]:
        lowerCamelCase    ,	lowerCamelCase :					int    =				unsorted[j - 1], unsorted[j]
        lowerCamelCase :					Optional[int]    =				True

    for j in range(SCREAMING_SNAKE_CASE_	):
      if unsorted[j] > unsorted[j + 1]:
        lowerCamelCase    ,	lowerCamelCase :					Union[str, Any]    =				unsorted[j + 1], unsorted[j]
        lowerCamelCase :					Optional[Any]    =				True

    if not swapped:
      break
  return unsorted


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   _snake_case             =     input('''Enter numbers separated by a comma:\n''').strip()
   _snake_case             =     [int(item) for item in user_input.split(''',''')]
   print(f'''{cocktail_shaker_sort(unsorted) = }''')



