code: import functools
  import operator
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  UpperCAmelCase     :   Union[str, Any]					=				logging.get_logger(__name__)
  
  UpperCAmelCase     :   Tuple					=				{
      '''facebook/hubert-base-ls960''': '''https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json''',
      # See all Hubert models at https://huggingface.co/models?filter=hubert
  }
  
  
  
  
  class    __lowerCAmelCase  (       a_						):
  
  
  
   '''simple docstring'''
   _lowerCamelCase						:	str				    = 'hubert'
  
   def __init__(			self       :		Optional[Any]       ,			lowerCamelCase       :		str=3_2       ,			lowerCamelCase       :		int=7_6_8       ,			lowerCamelCase       :		Dict=1_2       ,			lowerCamelCase       :		List[Any]=1_2       ,			lowerCamelCase       :		Optional[Any]=3_0_7_2       ,			lowerCamelCase       :		Tuple="gelu"       ,			lowerCamelCase       :		List[str]=0.1       ,			lowerCamelCase       :		List[Any]=0.1       ,			lowerCamelCase       :		str=0.1       ,			lowerCamelCase       :		Tuple=True       ,			lowerCamelCase       :		str=0.0       ,			lowerCamelCase       :		Optional[int]=0.1       ,			lowerCamelCase       :		Optional[int]=0.1       ,			lowerCamelCase       :		Any=0.0_2       ,			lowerCamelCase       :		int=1e-5       ,			lowerCamelCase       :		Tuple="group"       ,			lowerCamelCase       :		List[str]="gelu"       ,			lowerCamelCase       :		Optional[Any]=(5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2)       ,			lowerCamelCase       :		Any=(5, 2, 2, 2, 2, 2, 2)       ,			lowerCamelCase       :		Optional[int]=(1_0, 3, 3, 3, 3, 2, 2)       ,			lowerCamelCase       :		Optional[int]=False       ,			lowerCamelCase       :		str=1_2_8       ,			lowerCamelCase       :		Optional[Any]=1_6       ,			lowerCamelCase       :		Tuple=False       ,			lowerCamelCase       :		Dict=True       ,			lowerCamelCase       :		Any=0.0_5       ,			lowerCamelCase       :		List[str]=1_0       ,			lowerCamelCase       :		str=2       ,			lowerCamelCase       :		Tuple=0.0       ,			lowerCamelCase       :		Optional[int]=1_0       ,			lowerCamelCase       :		Dict=0       ,			lowerCamelCase       :		Optional[int]="sum"       ,			lowerCamelCase       :		List[str]=False       ,			lowerCamelCase       :		List[str]=False       ,			lowerCamelCase       :		int=2_5_6       ,			lowerCamelCase       :		Union[str, Any]=0       ,			lowerCamelCase       :		List[str]=1       ,			lowerCamelCase       :		Dict=2       ,			**lowerCamelCase       :		Any       ,			) ->							Any:
          super().__init__(**lowerCamelCase       ,			pad_token_id=lowerCamelCase       ,			bos_token_id=lowerCamelCase       ,			eos_token_id=lowerCamelCase  )
          _UpperCamelCase     :       Union[str, Any]  						=  hidden_size
          _UpperCamelCase     :       Optional[int]  						=  feat_extract_norm
          _UpperCamelCase     :       str  						=  feat_extract_activation
          _UpperCamelCase     :       List[Any]  						=  list(lowerCamelCase  )
          _UpperCamelCase     :       Optional[Any]  						=  list(lowerCamelCase  )
          _UpperCamelCase     :       str  						=  list(lowerCamelCase  )
          _UpperCamelCase     :       Dict  						=  conv_bias
          _UpperCamelCase     :       int  						=  num_conv_pos_embeddings
          _UpperCamelCase     :       Dict  						=  num_conv_pos_embedding_groups
          _UpperCamelCase     :       Dict  						=  len(self.conv_dim  )
          _UpperCamelCase     :       List[Any]  						=  num_hidden_layers
          _UpperCamelCase     :       Tuple  						=  intermediate_size
          _UpperCamelCase     :       Optional[Any]  						=  hidden_act
          _UpperCamelCase     :       List[str]  						=  num_attention_heads
          _UpperCamelCase     :       int  						=  hidden_dropout
          _UpperCamelCase     :       Optional[Any]  						=  attention_dropout
          _UpperCamelCase     :       Union[str, Any]  						=  activation_dropout
          _UpperCamelCase     :       Optional[Any]  						=  feat_proj_layer_norm
          _UpperCamelCase     :       Optional[Any]  						=  feat_proj_dropout
          _UpperCamelCase     :       List[Any]  						=  final_dropout
          _UpperCamelCase     :       Any  						=  layerdrop
          _UpperCamelCase     :       List[str]  						=  layer_norm_eps
          _UpperCamelCase     :       Tuple  						=  initializer_range
          _UpperCamelCase     :       str  						=  vocab_size
          _UpperCamelCase     :       Dict  						=  do_stable_layer_norm
          _UpperCamelCase     :       Dict  						=  use_weighted_layer_sum
          _UpperCamelCase     :       List[str]  						=  classifier_proj_size
  
          if (
              (len(self.conv_stride  ) != self.num_feat_extract_layers)
              or (len(self.conv_kernel  ) != self.num_feat_extract_layers)
              or (len(self.conv_dim  ) != self.num_feat_extract_layers)
          ):
                 raise ValueError(
                     'Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='
                     ' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='
                     f" {len(self.conv_dim  )}`, `len(config.conv_stride) = {len(self.conv_stride  )}`,"
                     f" `len(config.conv_kernel) = {len(self.conv_kernel  )}`."  )
  
          # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
          _UpperCamelCase     :       Any  						=  apply_spec_augment
          _UpperCamelCase     :       List[Any]  						=  mask_time_prob
          _UpperCamelCase     :       Tuple  						=  mask_time_length
          _UpperCamelCase     :       Union[str, Any]  						=  mask_time_min_masks
          _UpperCamelCase     :       str  						=  mask_feature_prob
          _UpperCamelCase     :       List[Any]  						=  mask_feature_length
          _UpperCamelCase     :       Union[str, Any]  						=  mask_feature_min_masks
  
          # ctc loss
          _UpperCamelCase     :       Any  						=  ctc_loss_reduction
          _UpperCamelCase     :       Any  						=  ctc_zero_infinity
  
   @property
   def 					__snake_case					(			self       :		Optional[Any]  ) ->							Tuple:
          return functools.reduce(operator.mul       ,			self.conv_stride       ,			1  )
  
  
  
  
style_context: import math
  from collections.abc import Generator
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
         _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)				))
         for i in (n for n in numbers if n > 1):
                for j in range(2		,						lowercase_				):
                       if (i % j) == 0:
                              break
                else:
                       yield i
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
         _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)				))
         for i in (n for n in numbers if n > 1):
                # only need to check for factors up to sqrt(i)
                _UpperCamelCase     :       Any  						=  int(math.sqrt(lowercase_				)				) + 1
                for j in range(2		,						lowercase_				):
                       if (i % j) == 0:
                              break
                else:
                       yield i
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
         _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)		,						2				))
         # It's useless to test even numbers as they will not be prime
         if max_n > 2:
                yield 2  # Because 2 will not be tested, it's necessary to yield it now
         for i in (n for n in numbers if n > 1):
                _UpperCamelCase     :       Tuple  						=  int(math.sqrt(lowercase_				)				) + 1
                for j in range(3		,						lowercase_		,						2				):
                       # As we removed the even numbers, we don't need them now
                       if (i % j) == 0:
                              break
                else:
                       yield i
  
  
  def SCREAMING_SNAKE_CASE				(     ):
         from timeit import timeit
  
         _UpperCamelCase     :       Optional[Any]  						=  'from __main__ import slow_primes, primes, fast_primes'
         print(timeit('slow_primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)
         print(timeit('primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)
         print(timeit('fast_primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)
  
  
  if __name__ == "__main__":
   UpperCAmelCase					=				int(input('''Calculate primes up to:\n>> ''').strip())
   for ret in primes(number):
    print(ret)
   benchmark()
  
  
  
  