





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

import numpy as np

class      snake_case     :




 """simple docstring"""



 def __init__(       self       :							Union[str, Any]	):
        __UpperCamelCase       =  [2, 1, 2, -1]
        __UpperCamelCase       =  [1, 2, 3, 4]






 def        _lowerCamelCase					(       self       :							str	):
        __UpperCamelCase       =  len(self.first_signal	)
        __UpperCamelCase       =  len(self.second_signal	)

        __UpperCamelCase       =  max(__A							,	__A	)

        # create a zero matrix of max_length x max_length
        __UpperCamelCase       =  [[0] * max_length for i in range(__A	)]

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

        # multiply the matrix with the first signal
        __UpperCamelCase       =  np.matmul(np.transpose(__A	)							,	np.transpose(self.first_signal	)	)

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


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


import random

from .binary_exp_mod import bin_exp_mod



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__=1000		):
					'''simple docstring'''
					if n < 2:
										return False

					if n % 2 == 0:
										return n == 2

					# this means n is odd
					lowercase							=						n - 1
					lowercase							=						0
					while d % 2 == 0:
										d /= 2
										exp += 1

					# n - 1=d*(2**exp)
					lowercase							=						0
					while count < prec:
										lowercase							=						random.randint(2 ,			n - 1		)
										lowercase							=						bin_exp_mod(lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__		)
										if b != 1:
															lowercase							=						True
															for _ in range(lowerCAmelCase__		):
																				if b == n - 1:
																									lowercase							=						False
																									break
																				lowercase							=						b * b
																				b %= n
															if flag:
																				return False
															count += 1
					return True


if __name__ == "__main__":
							lowercase__		:Tuple   =    abs(int(input("Enter bound : ").strip()))
							print("Here's the list of primes:")
							print(", ".join(str(i) for i in range(n + 1) if is_prime_big(i)))




