"""simple docstring"""






def 						a_		(      lowerCamelCase ):
				UpperCAmelCase__    =							current_set.copy()
				for row_index, row in enumerate(lowerCamelCase ):
								UpperCAmelCase__    =							row[0]
								for column_index, column in enumerate(lowerCamelCase ):
												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(lowerCamelCase )
												continue
								for column_index in range(len(lowerCamelCase ) ):
												temp_row.append(first_row[column_index] - row[column_index] )
								final_set.append(lowerCamelCase )
				# 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(lowerCamelCase )
								for i in range(len(lowerCamelCase ) ):
												resultant[i].insert(0      ,    current_first_column[i] )
								resultant.insert(0      ,    lowerCamelCase )
								UpperCAmelCase__    =							resultant
				return final_set



def 						a_		(      lowerCamelCase ):
				if len(lowerCamelCase ) == 0:
								raise IndexError('solve_simultaneous() requires n lists of length n+1' )
				UpperCAmelCase__    =							len(lowerCamelCase ) + 1
				if any(len(lowerCamelCase ) != _length for item in equations ):
								raise IndexError('solve_simultaneous() requires n lists of length n+1' )
				for row in equations:
								if any(not isinstance(lowerCamelCase      ,    (int, float) ) for column in row ):
												raise ValueError('solve_simultaneous() requires lists of integers' )
				if len(lowerCamelCase ) == 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(lowerCamelCase ):
												if 0 not in row:
																UpperCAmelCase__    =							data_set.pop(lowerCamelCase )
																break
								if not full_row:
												raise ValueError('solve_simultaneous() requires at least 1 full equation' )
								data_set.insert(0      ,    lowerCamelCase )
				UpperCAmelCase__    =							data_set.copy()
				UpperCAmelCase__    =							simplify(lowerCamelCase )
				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(lowerCamelCase ) - 1 :]
								while temp_row[0] == 0:
												temp_row.pop(0 )
								if len(lowerCamelCase ) == 0:
												solutions.append(0 )
												continue
								UpperCAmelCase__    =							temp_row[1::]
								UpperCAmelCase__    =							temp_row[::-1]
								for column_index, column in enumerate(lowerCamelCase ):
												current_solution -= column * solutions[column_index]
								solutions.append(lowerCamelCase )
				UpperCAmelCase__    =							[]
				for item in solutions:
								final.append(float(round(lowerCamelCase      ,    5 ) ) )
				return final[::-1]


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						lowerCAmelCase__						:						Dict		  =			[
						    [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"""






def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return x if y == 0 else greatest_common_divisor(lowerCamelCase      ,    x % y )



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return (x * y) // greatest_common_divisor(lowerCamelCase      ,    lowerCamelCase )



def 						a_		(      lowerCamelCase = 2_0 ):
				UpperCAmelCase__    =							1
				for i in range(1      ,    n + 1 ):
								UpperCAmelCase__    =							lcm(lowerCamelCase      ,    lowerCamelCase )
				return g


if __name__ == "__main__":
						print(F"""{solution() = }""")



