


def 							UpperCamelCase_(					_A :int					,  _A :int	)->		int:
			return abs(_A	) if a == 0 else greatest_common_divisor(b % a					,  _A	)
def 							UpperCamelCase_(					_A :int					,  _A :int	)->		int:
			while y:  # --> when y=0 then loop will terminate and return x as final GCD.
						UpperCamelCase__,   UpperCamelCase__       =							y, x % y
			return abs(_A	)
def 							UpperCamelCase_(					)->		Dict:
			try:
						UpperCamelCase__       =							input("Enter two integers separated by comma (,): "	).split(","	)
						UpperCamelCase__       =							int(nums[0]	)
						UpperCamelCase__       =							int(nums[1]	)
						print(
						    F'''greatest_common_divisor({num_a}, {num_a}) = '''
						    F'''{greatest_common_divisor(_A					,  _A	)}'''	)
						print(F'''By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(_A					,  _A	)}'''	)
			except (IndexError, UnboundLocalError, ValueError):
						print("Wrong input"	)


if __name__ == "__main__":
						main()






def 							UpperCamelCase_(					_A :list[list]	)->		list[list]:
			UpperCamelCase__       =							current_set.copy()
			for row_index, row in enumerate(_A	):
						UpperCamelCase__       =							row[0]
						for column_index, column in enumerate(_A	):
									if magnitude == 0:
												UpperCamelCase__       =							column
												continue
									UpperCamelCase__       =							column / magnitude
    # Subtract to cancel term
			UpperCamelCase__       =							current_set[0]
			UpperCamelCase__       =							[first_row]
			UpperCamelCase__       =							current_set[1::]
			for row in current_set:
						UpperCamelCase__       =							[]
						# 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:
						UpperCamelCase__       =							final_set[0]
						UpperCamelCase__       =							[]
						UpperCamelCase__       =							[]
						for row in final_set[1::]:
									current_first_column.append(row[0]	)
									next_iteration.append(row[1::]	)
						UpperCamelCase__       =							simplify(_A	)
						for i in range(len(_A	)	):
									resultant[i].insert(0					,  current_first_column[i]	)
						resultant.insert(0					,  _A	)
						UpperCamelCase__       =							resultant
			return final_set
def 							UpperCamelCase_(					_A :list[list]	)->		list:
			if len(_A	) == 0:
						raise IndexError("solve_simultaneous() requires n lists of length n+1"	)
			UpperCamelCase__       =							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]]
			UpperCamelCase__       =							equations.copy()
			if any(0 in row for row in data_set	):
						UpperCamelCase__       =							data_set.copy()
						UpperCamelCase__       =							[]
						for row_index, row in enumerate(_A	):
									if 0 not in row:
												UpperCamelCase__       =							data_set.pop(_A	)
												break
						if not full_row:
									raise ValueError("solve_simultaneous() requires at least 1 full equation"	)
						data_set.insert(0					,  _A	)
			UpperCamelCase__       =							data_set.copy()
			UpperCamelCase__       =							simplify(_A	)
			UpperCamelCase__       =							simplified[::-1]
			UpperCamelCase__       =							[]
			for row in simplified:
						UpperCamelCase__       =							row[-1]
						if not solutions:
									if row[-2] == 0:
												solutions.append(0	)
												continue
									solutions.append(current_solution / row[-2]	)
									continue
						UpperCamelCase__       =							row.copy()[: len(_A	) - 1 :]
						while temp_row[0] == 0:
									temp_row.pop(0	)
						if len(_A	) == 0:
									solutions.append(0	)
									continue
						UpperCamelCase__       =							temp_row[1::]
						UpperCamelCase__       =							temp_row[::-1]
						for column_index, column in enumerate(_A	):
									current_solution -= column * solutions[column_index]
						solutions.append(_A	)
			UpperCamelCase__       =							[]
			for item in solutions:
						final.append(float(round(_A					,  5	)	)	)
			return final[::-1]


if __name__ == "__main__":
						import doctest

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


