


import doctest
from collections import deque

import numpy as np


class     lowercase__  :






  def __init__(					self      :					str ):




         """simple docstring"""







         UpperCAmelCase__										=     [2, 1, 2, -1]
         UpperCAmelCase__										=     [1, 2, 3, 4]






  def 			_UpperCAmelCase  (					self      :					List[str] ):




         """simple docstring"""







         UpperCAmelCase__										=     len(self.first_signal )
         UpperCAmelCase__										=     len(self.second_signal )

         UpperCAmelCase__										=     max(_lowercase		,						_lowercase )

         # create a zero matrix of max_length x max_length
         UpperCAmelCase__										=     [[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 ):
                UpperCAmelCase__										=     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
         UpperCAmelCase__										=     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()









from __future__ import annotations





def __UpperCAmelCase       (		__A			)						->					list[int]:



       '''simple docstring'''





       UpperCAmelCase__										=     [True] * limit
       UpperCAmelCase__										=     False
       UpperCAmelCase__										=     False
       UpperCAmelCase__										=     True

       for i in range(3 ,						int(limit**0.5 + 1			) ,						2			):
              UpperCAmelCase__										=     i * 2
              while index < limit:
                     UpperCAmelCase__										=     False
                     UpperCAmelCase__										=     index + i

       UpperCAmelCase__										=     [2]

       for i in range(3 ,						__A ,						2			):
              if is_prime[i]:
                     primes.append(__A			)

       return primes





def __UpperCAmelCase       (		__A = 1_0_0_0_0_0_0			)						->					int:



       '''simple docstring'''





       UpperCAmelCase__										=     prime_sieve(__A			)
       UpperCAmelCase__										=     0
       UpperCAmelCase__										=     0

       for i in range(len(__A			)			):
              for j in range(i + length ,						len(__A			)			):
                     UpperCAmelCase__										=     sum(primes[i:j]			)
                     if sol >= ceiling:
                            break

                     if sol in primes:
                            UpperCAmelCase__										=     j - i
                            UpperCAmelCase__										=     sol

       return largest


if __name__ == "__main__":
    print(f"{solution() = }")





