


'''simple docstring'''







def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int  )  ->			Any:
       return [
           {
               0: [1, 2],
               1: [0, 2],
               2: [0, 1, 3, 5],
               3: [2, 4],
               4: [3],
               5: [2, 6, 8],
               6: [5, 7],
               7: [6, 8],
               8: [5, 7],
           },
           {
               0: [6],
               1: [9],
               2: [4, 5],
               3: [4],
               4: [2, 3],
               5: [2],
               6: [0, 7],
               7: [6],
               8: [],
               9: [1],
           },
           {
               0: [4],
               1: [6],
               2: [],
               3: [5, 6, 7],
               4: [0, 6],
               5: [3, 8, 9],
               6: [1, 3, 4, 7],
               7: [3, 6, 8, 9],
               8: [5, 7],
               9: [5, 7],
           },
           {
               0: [1, 3],
               1: [0, 2, 4],
               2: [1, 3, 4],
               3: [0, 2, 4],
               4: [1, 2, 3],
           },
       ][index]


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	dict[int, list[int]]  )  ->			list[tuple[int, int]]:
       _a    : Optional[int]     					=0
       _a    : Union[str, Any]     					=len(_UpperCAmelCase  )  # No of vertices in graph
       _a    : List[str]     					=[0] * n
       _a    : int     					=[False] * n

       def dfs(_UpperCAmelCase	:	Any    ,_UpperCAmelCase	:	List[str]    ,_UpperCAmelCase	:	Any    ,_UpperCAmelCase	:	Any  ):
              _a    : Optional[Any]     					=True
              _a    : Optional[Any]     					=id_
              id_ += 1
              for to in graph[at]:
                     if to == parent:
                            pass
                     elif not visited[to]:
                            dfs(_UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase    ,id_  )
                            _a    : str     					=min(low[at]    ,low[to]  )
                            if id_ <= low[to]:
                                   bridges.append((at, to) if at < to else (to, at)  )
                     else:
                            # This edge is a back edge and cannot be a bridge
                            _a    : List[Any]     					=min(low[at]    ,low[to]  )

       _a    : list[tuple[int, int]]     					=[]
       for i in range(_UpperCAmelCase  ):
              if not visited[i]:
                     dfs(_UpperCAmelCase    ,-1    ,_UpperCAmelCase    ,id_  )
       return bridges


if __name__ == "__main__":
   import doctest

   doctest.testmod()






'''simple docstring'''







from __future__ import annotations







class A__       :






      def __init__( self			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:str	)       ->					Optional[int]:




             '''simple docstring'''
             _a					,    _a    : List[str]     					=text, pattern
             _a					,    _a    : Union[str, Any]     					=len(SCREAMING_SNAKE_CASE	), len(SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:str	)       ->					int:




             '''simple docstring'''

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






      def __UpperCAmelCase       ( self			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:int	)       ->					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 __UpperCAmelCase       ( self			:Union[str, Any]	)       ->					list[int]:




             '''simple docstring'''
             # searches pattern in text and returns index positions
             _a    : Union[str, Any]     					=[]
             for i in range(self.textLen - self.patLen + 1	):
                    _a    : Any     					=self.mismatch_in_text(SCREAMING_SNAKE_CASE	)
                    if mismatch_index == -1:
                           positions.append(SCREAMING_SNAKE_CASE	)
                    else:
                           _a    : int     					=self.match_in_pattern(self.text[mismatch_index]	)
                           _a    : List[str]     					=(
                               mismatch_index - match_index
                           )  # shifting index lgtm [py/multiple-definition]
             return positions

A__:    Any					    =       '''ABAABA'''
A__:    int					    =       '''AB'''
A__:    Optional[int]					    =       BoyerMooreSearch(text, pattern)
A__:    Optional[Any]					    =       bms.bad_character_heuristic()

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


