'''simple docstring'''

__a: List[Any]          =   {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

__a: List[Any]          =   {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    str  =					True
 lowercase__				:    Union[str, Any]  =					[]

 for neighbour in graph[vert]:
  if not visited[neighbour]:
   order += topology_sort(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )

 order.append(UpperCAmelCase     )

 return order
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					True
 lowercase__				:    List[str]  =					[vert]

 for neighbour in reversed_graph[vert]:
  if not visited[neighbour]:
   component += find_components(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )

 return component





def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    str  =					len(UpperCAmelCase     ) * [False]
 lowercase__				:    dict[int, list[int]]  =					{vert: [] for vert in range(len(UpperCAmelCase     )     )}

 for vert, neighbours in graph.items():
  for neighbour in neighbours:
   reversed_graph[neighbour].append(UpperCAmelCase     )

 lowercase__				:    Union[str, Any]  =					[]
 for i, was_visited in enumerate(UpperCAmelCase     ):
  if not was_visited:
   order += topology_sort(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )

 lowercase__				:    Any  =					[]
 lowercase__				:    Any  =					len(UpperCAmelCase     ) * [False]

 for i in range(len(UpperCAmelCase     )     ):
  lowercase__				:    Any  =					order[len(UpperCAmelCase     ) - i - 1]
  if not visited[vert]:
   lowercase__				:    List[Any]  =					find_components(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )
   components_list.append(UpperCAmelCase     )

 return components_list


'''simple docstring'''

import doctest
from collections import deque

import numpy as np



class 			UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self )  ->  None:
        lowercase__				:    str  =					[2, 1, 2, -1]
        lowercase__				:    str  =					[1, 2, 3, 4]


       def _lowerCAmelCase(						self )  ->  list[float]:
        lowercase__				:    Optional[Any]  =					len(self.first_signal )
        lowercase__				:    Union[str, Any]  =					len(self.second_signal )

        lowercase__				:    int  =					max(__lowerCAmelCase	,   __lowerCAmelCase )

        # create a zero matrix of max_length x max_length
        lowercase__				:    List[str]  =					[[0] * max_length for i in range(__lowerCAmelCase )]

        # 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(__lowerCAmelCase ):
         lowercase__				:    int  =					deque(self.second_signal )
         rotated_signal.rotate(__lowerCAmelCase )
         for j, item in enumerate(__lowerCAmelCase ):
          matrix[i][j] += item

        # multiply the matrix with the first signal
        lowercase__				:    Optional[int]  =					np.matmul(np.transpose(__lowerCAmelCase )	,   np.transpose(self.first_signal ) )

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


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

