
'''simple docstring'''
def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    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 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Optional[int]     			=						0
    snake_case_ :    Any     			=						len(__SCREAMING_SNAKE_CASE       )  # No of vertices in graph
    snake_case_ :    List[str]     			=						[0] * n
    snake_case_ :    str     			=						[False] * n

    def dfs(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
        snake_case_ :    Any     			=						True
        snake_case_ :    int     			=						id_
        id_ += 1
        for to in graph[at]:
            if to == parent:
                pass
            elif not visited[to]:
                dfs(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		id_       )
                snake_case_ :    List[Any]     			=						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
                snake_case_ :    Optional[Any]     			=						min(low[at],		low[to]       )

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


if __name__ == "__main__":
  import doctest

  doctest.testmod()






'''simple docstring'''
import doctest
from collections import deque

import numpy as np






class    UpperCAmelCase_				:





 def __init__(    self):
     snake_case_ :    List[Any]     			=						[2, 1, 2, -1]
     snake_case_ :    int     			=						[1, 2, 3, 4]





 def        snake_case__		(    self):
     snake_case_ :    str     			=						len(self.first_signal)
     snake_case_ :    Any     			=						len(self.second_signal)

     snake_case_ :    List[Any]     			=						max(lowercase_ ,       lowercase_)

     # create a zero matrix of max_length x max_length
     snake_case_ :    Dict     			=						[[0] * max_length for i in range(lowercase_)]

     # fills the smaller signal with zeros to make both signals of same length
     if length_first_signal < length_second_signal:
         self.first_signal += [0] * (max_length - length_first_signal)
     elif length_first_signal > length_second_signal:
         self.second_signal += [0] * (max_length - length_second_signal)
     for i in range(lowercase_):
         snake_case_ :    List[str]     			=						deque(self.second_signal)
         rotated_signal.rotate(lowercase_)
         for j, item in enumerate(lowercase_):
             matrix[i][j] += item

        # multiply the matrix with the first signal
     snake_case_ :    Any     			=						np.matmul(np.transpose(lowercase_) ,       np.transpose(self.first_signal))

     # rounding-off to two decimal places
     return [round(lowercase_ ,       2) for i in final_signal]


if __name__ == "__main__":
  doctest.testmod()




