





class 					A__   :





      def __init__( self       ,							A_       ,							A_=None       ,							A_=None   ):
       '''simple docstring'''




       UpperCamelCase	:					List[str]       	=   data
       UpperCamelCase	:					Optional[int]       	=   previous
       UpperCamelCase	:					Optional[Any]       	=   next_node





      def __str__( self   ):
       '''simple docstring'''




       return F"""{self.data}"""





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return self.data





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return self.next





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return self.previous



class 					A__   :





      def __init__( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[Any]       	=   head





      def __iter__( self   ):
       '''simple docstring'''




       return self





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if not self.current:
        raise StopIteration
       else:
        UpperCamelCase	:					Optional[Any]       	=   self.current.get_data()
        UpperCamelCase	:					List[str]       	=   self.current.get_next()
        return value



class 					A__   :





      def __init__( self   ):
       '''simple docstring'''




       UpperCamelCase	:					Any       	=   None  # First node in list
       UpperCamelCase	:					Optional[int]       	=   None  # Last node in list





      def __str__( self   ):
       '''simple docstring'''




       UpperCamelCase	:					str       	=   self.head
       UpperCamelCase	:					Tuple       	=   []
       while current is not None:
        nodes.append(current.get_data()   )
        UpperCamelCase	:					Dict       	=   current.get_next()
       return " ".join(str(A_   ) for node in nodes   )





      def __contains__( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   self.head
       while current:
        if current.get_data() == value:
         return True
        UpperCamelCase	:					Tuple       	=   current.get_next()
       return False





      def __iter__( self   ):
       '''simple docstring'''




       return LinkedListIterator(self.head   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if self.head:
        return self.head.get_data()
       return None





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if self.tail:
        return self.tail.get_data()
       return None





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       if self.head is None:
        UpperCamelCase	:					List[Any]       	=   node
        UpperCamelCase	:					Union[str, Any]       	=   node
       else:
        self.insert_before_node(self.head       ,							A_   )





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       if self.head is None:
        self.set_head(A_   )
       else:
        self.insert_after_node(self.tail       ,							A_   )





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[int]       	=   Node(A_   )
       if self.head is None:
        self.set_head(A_   )
       else:
        self.set_tail(A_   )





      def        __UpperCamelCase( self       ,							A_       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[int]       	=   node
       UpperCamelCase	:					List[Any]       	=   node.previous

       if node.get_previous() is None:
        UpperCamelCase	:					str       	=   node_to_insert
       else:
        UpperCamelCase	:					Dict       	=   node_to_insert

       UpperCamelCase	:					Optional[Any]       	=   node_to_insert





      def        __UpperCamelCase( self       ,							A_       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   node
       UpperCamelCase	:					Optional[Any]       	=   node.next

       if node.get_next() is None:
        UpperCamelCase	:					List[str]       	=   node_to_insert
       else:
        UpperCamelCase	:					int       	=   node_to_insert

       UpperCamelCase	:					Union[str, Any]       	=   node_to_insert





      def        __UpperCamelCase( self       ,							A_       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					List[Any]       	=   1
       UpperCamelCase	:					Tuple       	=   Node(A_   )
       UpperCamelCase	:					Optional[int]       	=   self.head
       while node:
        if current_position == position:
         self.insert_before_node(A_       ,							A_   )
         return
        current_position += 1
        UpperCamelCase	:					Union[str, Any]       	=   node.next
       self.insert_after_node(self.tail       ,							A_   )





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Union[str, Any]       	=   self.head
       while node:
        if node.get_data() == item:
         return node
        UpperCamelCase	:					int       	=   node.get_next()
       raise Exception("Node not found"   )





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       if (node := self.get_node(A_   )) is not None:
        if node == self.head:
         UpperCamelCase	:					Optional[Any]       	=   self.head.get_next()

        if node == self.tail:
         UpperCamelCase	:					Dict       	=   self.tail.get_previous()

        self.remove_node_pointers(A_   )





      @staticmethod
      def        __UpperCamelCase( A_   ):
       '''simple docstring'''




       if node.get_next():
        UpperCamelCase	:					List[str]       	=   node.previous

       if node.get_previous():
        UpperCamelCase	:					Dict       	=   node.next

       UpperCamelCase	:					Any       	=   None
       UpperCamelCase	:					Optional[Any]       	=   None





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return self.head is None



def 		A_				(     )						-> None:
 pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()








"""simple docstring"""




def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''

  # Check if the input is valid
  if not len(UpperCamelCase__				) == len(UpperCamelCase__				) == 3:
    raise ValueError("""Please enter a valid equation."""				)
  if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
    raise ValueError("""Both a & b of two equations can't be zero."""				)

  # Extract the coefficients
  _a      ,  _a      ,  _a  :       Any             =	equationa
  _a      ,  _a      ,  _a  :       Tuple             =	equationa

  # Calculate the determinants of the matrices
  _a  :       int             =	aa * ba - aa * ba
  _a  :       str             =	ca * ba - ca * ba
  _a  :       str             =	aa * ca - aa * ca

  # Check if the system of linear equations has a solution (using Cramer's rule)
  if determinant == 0:
    if determinant_x == determinant_y == 0:
      raise ValueError("""Infinite solutions. (Consistent system)"""				)
    else:
      raise ValueError("""No solution. (Inconsistent system)"""				)
  else:
    if determinant_x == determinant_y == 0:
      # Trivial solution (Inconsistent system)
      return (0.0, 0.0)
    else:
      _a  :       Dict             =	determinant_x / determinant
      _a  :       str             =	determinant_y / determinant
      # Non-Trivial Solution (Consistent system)
      return (x, y)

