

def 						lowerCamelCase__      ( __A    :list[int]	,__A    :list[int]		):


       """simple docstring"""




       if not len(__A		) == len(__A		) == 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
       __snake_case	,    __snake_case	,    __snake_case       	=							equationa
       __snake_case	,    __snake_case	,    __snake_case       	=							equationa

       # Calculate the determinants of the matrices
       __snake_case       	=							aa * ba - aa * ba
       __snake_case       	=							ca * ba - ca * ba
       __snake_case       	=							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:
                     __snake_case       	=							determinant_x / determinant
                     __snake_case       	=							determinant_y / determinant
                     # Non-Trivial Solution (Consistent system)
                     return (x, y)




from __future__ import annotations

class     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase      , _UpperCamelCase   )      ->							Tuple:






              """simple docstring"""


              __snake_case	,    __snake_case       	=							text, pattern
              __snake_case	,    __snake_case       	=							len(_UpperCamelCase   ), len(_UpperCamelCase   )


       def 			a		(		self      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


              for i in range(self.patLen - 1      , -1      , -1   ):
                     if char == self.pattern[i]:
                            return i
              return -1


       def 			a		(		self      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


              for i in range(self.patLen - 1      , -1      , -1   ):
                     if self.pattern[i] != self.text[current_pos + i]:
                            return current_pos + i
              return -1






       def 			a		(		self   )      ->							list[int]:






              """simple docstring"""


              __snake_case       	=							[]
              for i in range(self.textLen - self.patLen + 1   ):
                     __snake_case       	=							self.mismatch_in_text(_UpperCamelCase   )
                     if mismatch_index == -1:
                            positions.append(_UpperCamelCase   )
                     else:
                            __snake_case       	=							self.match_in_pattern(self.text[mismatch_index]   )
                            __snake_case       	=							(
                                mismatch_index - match_index
                            )  # shifting index lgtm [py/multiple-definition]
              return positions






UpperCamelCase__		 =     '''ABAABA'''
UpperCamelCase__		 =     '''AB'''
UpperCamelCase__		 =     BoyerMooreSearch(text, pattern)
UpperCamelCase__		 =     bms.bad_character_heuristic()

if len(positions) == 0:
    print('''No match found''')
else:
    print('''Pattern found in following positions: ''')
    print(positions)

