





def    A_  (							a  ):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  str           =     current_set.copy()
      for row_index, row in enumerate(a  ):
            SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     row[0]
            for column_index, column in enumerate(a  ):
                  if magnitude == 0:
                        SCREAMING_SNAKE_CASE_				:  Any           =     column
                        continue
                  SCREAMING_SNAKE_CASE_				:  List[str]           =     column / magnitude
    # Subtract to cancel term
      SCREAMING_SNAKE_CASE_				:  Tuple           =     current_set[0]
      SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     [first_row]
      SCREAMING_SNAKE_CASE_				:  Any           =     current_set[1::]
      for row in current_set:
            SCREAMING_SNAKE_CASE_				:  Tuple           =     []
            # 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:
            SCREAMING_SNAKE_CASE_				:  List[str]           =     final_set[0]
            SCREAMING_SNAKE_CASE_				:  Tuple           =     []
            SCREAMING_SNAKE_CASE_				:  Any           =     []
            for row in final_set[1::]:
                  current_first_column.append(row[0]  )
                  next_iteration.append(row[1::]  )
            SCREAMING_SNAKE_CASE_				:  int           =     simplify(a  )
            for i in range(len(a  )  ):
                  resultant[i].insert(0					,   current_first_column[i]  )
            resultant.insert(0					,   a  )
            SCREAMING_SNAKE_CASE_				:  List[str]           =     resultant
      return final_set

def    A_  (							a  ):

      """simple docstring"""



      if len(a  ) == 0:
            raise IndexError('solve_simultaneous() requires n lists of length n+1'  )
      SCREAMING_SNAKE_CASE_				:  str           =     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]]
      SCREAMING_SNAKE_CASE_				:  List[str]           =     equations.copy()
      if any(0 in row for row in data_set  ):
            SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     data_set.copy()
            SCREAMING_SNAKE_CASE_				:  Any           =     []
            for row_index, row in enumerate(a  ):
                  if 0 not in row:
                        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     data_set.pop(a  )
                        break
            if not full_row:
                  raise ValueError('solve_simultaneous() requires at least 1 full equation'  )
            data_set.insert(0					,   a  )
      SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     data_set.copy()
      SCREAMING_SNAKE_CASE_				:  str           =     simplify(a  )
      SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     simplified[::-1]
      SCREAMING_SNAKE_CASE_				:  list           =     []
      for row in simplified:
            SCREAMING_SNAKE_CASE_				:  List[Any]           =     row[-1]
            if not solutions:
                  if row[-2] == 0:
                        solutions.append(0  )
                        continue
                  solutions.append(current_solution / row[-2]  )
                  continue
            SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     row.copy()[: len(a  ) - 1 :]
            while temp_row[0] == 0:
                  temp_row.pop(0  )
            if len(a  ) == 0:
                  solutions.append(0  )
                  continue
            SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     temp_row[1::]
            SCREAMING_SNAKE_CASE_				:  int           =     temp_row[::-1]
            for column_index, column in enumerate(a  ):
                  current_solution -= column * solutions[column_index]
            solutions.append(a  )
      SCREAMING_SNAKE_CASE_				:  Optional[int]           =     []
      for item in solutions:
            final.append(float(round(a					,   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]]))









def    A_  (							a					,   a  ):

      """simple docstring"""



      return int((input_a, input_a).count(0  ) != 0  )

def    A_  (							):

      """simple docstring"""



      assert nand_gate(0					,   0  ) == 1
      assert nand_gate(0					,   1  ) == 1
      assert nand_gate(1					,   0  ) == 1
      assert nand_gate(1					,   1  ) == 0


if __name__ == "__main__":
    print(nand_gate(0, 0))
    print(nand_gate(0, 1))
    print(nand_gate(1, 0))
    print(nand_gate(1, 1))






