





from __future__ import annotations



class   _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''

 def __init__(self							:  Any			,					UpperCAmelCase_							:  int)			->None:



   '''simple docstring'''



   lowerCamelCase__: List[str]         =order

   # a_{0} ... a_{k}
   lowerCamelCase__: Tuple         =[1.0] + [0.0] * order
   # b_{0} ... b_{k}
   lowerCamelCase__: Any         =[1.0] + [0.0] * order

   # x[n-1] ... x[n-k]
   lowerCamelCase__: int         =[0.0] * self.order
   # y[n-1] ... y[n-k]
   lowerCamelCase__: List[Any]         =[0.0] * self.order

 def 				SCREAMING_SNAKE_CASE_   (self							:  Optional[int]			,					UpperCAmelCase_							:  list[float]			,					UpperCAmelCase_							:  list[float])			->None:



   '''simple docstring'''



   if len(UpperCAmelCase_) < self.order:
     lowerCamelCase__: Tuple         =[1.0, *a_coeffs]

   if len(UpperCAmelCase_) != self.order + 1:
     lowerCamelCase__: List[str]         =(
         F"""Expected a_coeffs to have {self.order + 1} elements """
         F"""for {self.order}-order filter, got {len(UpperCAmelCase_)}"""
     )
     raise ValueError(UpperCAmelCase_)

   if len(UpperCAmelCase_) != self.order + 1:
     lowerCamelCase__: List[Any]         =(
         F"""Expected b_coeffs to have {self.order + 1} elements """
         F"""for {self.order}-order filter, got {len(UpperCAmelCase_)}"""
     )
     raise ValueError(UpperCAmelCase_)

   lowerCamelCase__: Tuple         =a_coeffs
   lowerCamelCase__: List[Any]         =b_coeffs







 def 				SCREAMING_SNAKE_CASE_   (self							:  str			,					UpperCAmelCase_							:  float)			->float:



   '''simple docstring'''



   lowerCamelCase__: List[Any]         =0.0

   # Start at index 1 and do index 0 at the end.
   for i in range(1			,					self.order + 1):
     result += (
         self.b_coeffs[i] * self.input_history[i - 1]
         - self.a_coeffs[i] * self.output_history[i - 1]
     )

   lowerCamelCase__: Union[str, Any]         =(result + self.b_coeffs[0] * sample) / self.a_coeffs[0]

   lowerCamelCase__: str         =self.input_history[:-1]
   lowerCamelCase__: Any         =self.output_history[:-1]

   lowerCamelCase__: int         =sample
   lowerCamelCase__: Tuple         =result

   return result









'''simple docstring'''







import math





def 		_UpperCAmelCase (				__A				: int   ):
				a_		:	str									=   []
				a_		:	Tuple									=   2
				a_		:	Optional[Any]									=   int(math.sqrt(__A   )   )  # Size of every segment
				a_		:	Optional[Any]									=   [True] * (end + 1)
				a_		:	Union[str, Any]									=   []

				while start <= end:
								if temp[start] is True:
												in_prime.append(__A   )
												for i in range(start * start    ,		end + 1    ,		__A   ):
																a_		:	List[Any]									=   False
								start += 1
				prime += in_prime

				a_		:	Any									=   end + 1
				a_		:	Optional[Any]									=   min(2 * end    ,		__A   )

				while low <= n:
								a_		:	Optional[Any]									=   [True] * (high - low + 1)
								for each in in_prime:
												a_		:	Any									=   math.floor(low / each   ) * each
												if t < low:
																t += each

												for j in range(__A    ,		high + 1    ,		__A   ):
																a_		:	Union[str, Any]									=   False

								for j in range(len(__A   )   ):
												if temp[j] is True:
																prime.append(j + low   )

								a_		:	Tuple									=   high + 1
								a_		:	str									=   min(high + end    ,		__A   )

				return prime




print(sieve(10**6))




