






def   a_			(   _A	)      ->      list[list]:







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







				"""simple docstring"""





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


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							__UpperCamelCase       :		str							=    [
							    [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]]))








"""simple docstring"""



__snake_case       =       """ABCDEFGHIJKLMNOPQRSTUVWXYZ"""







def     __lowerCAmelCase		(		)      ->		None:


    """simple docstring"""





    snake_case       : str    =       input("Enter message: "					)
    snake_case       : Tuple    =       input("Enter key [alphanumeric]: "					)
    snake_case       : Union[str, Any]    =       input("Encrypt/Decrypt [e/d]: "					)

    if mode.lower().startswith("e"					):
        snake_case       : str    =       "encrypt"
        snake_case       : Optional[int]    =       encrypt_message(lowercase		,				lowercase					)
    elif mode.lower().startswith("d"					):
        snake_case       : List[Any]    =       "decrypt"
        snake_case       : Tuple    =       decrypt_message(lowercase		,				lowercase					)

    print(F'\n{mode.title()}ed message:'					)
    print(lowercase					)







def     __lowerCAmelCase		(		lowercase    :    str		,				lowercase    :    str					)      ->		str:


    """simple docstring"""





    return translate_message(lowercase		,				lowercase		,				"encrypt"					)







def     __lowerCAmelCase		(		lowercase    :    str		,				lowercase    :    str					)      ->		str:


    """simple docstring"""





    return translate_message(lowercase		,				lowercase		,				"decrypt"					)







def     __lowerCAmelCase		(		lowercase    :    str		,				lowercase    :    str		,				lowercase    :    str					)      ->		str:


    """simple docstring"""





    snake_case       : List[Any]    =       []
    snake_case       : List[str]    =       0
    snake_case       : List[Any]    =       key.upper()

    for symbol in message:
        snake_case       : Optional[int]    =       LETTERS.find(symbol.upper()					)
        if num != -1:
            if mode == "encrypt":
                num += LETTERS.find(key[key_index]					)
            elif mode == "decrypt":
                num -= LETTERS.find(key[key_index]					)

            num %= len(lowercase					)

            if symbol.isupper():
                translated.append(LETTERS[num]					)
            elif symbol.islower():
                translated.append(LETTERS[num].lower()					)

            key_index += 1
            if key_index == len(lowercase					):
                snake_case       : List[str]    =       0
        else:
            translated.append(lowercase					)
    return "".join(lowercase					)


if __name__ == "__main__":
  main()





