





from ...configuration_utils import PretrainedConfig
from ...utils import logging


a__: Optional[int]							   =						logging.get_logger(__name__)

a__: str							   =						{
    'tiiuae/falcon-40b': 'https://huggingface.co/tiiuae/falcon-40b/resolve/main/config.json',
    'tiiuae/falcon-7b': 'https://huggingface.co/tiiuae/falcon-7b/resolve/main/config.json',
}




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):
 __SCREAMING_SNAKE_CASE							=      '''falcon'''
 __SCREAMING_SNAKE_CASE							=      ['''past_key_values''']



 def __init__(				self,__lowerCamelCase=6_5024,__lowerCamelCase=4544,__lowerCamelCase=32,__lowerCamelCase=71,__lowerCamelCase=1E-5,__lowerCamelCase=0.02,__lowerCamelCase=True,__lowerCamelCase=0.0,__lowerCamelCase=0.0,__lowerCamelCase=None,__lowerCamelCase=False,__lowerCamelCase=False,__lowerCamelCase=True,__lowerCamelCase=True,__lowerCamelCase=False,__lowerCamelCase=11,__lowerCamelCase=11,**__lowerCamelCase,):
        A__		   =		vocab_size
        # Backward compatibility with n_embed kwarg
        A__		   =		kwargs.pop('''n_embed''',__lowerCamelCase					)
        A__		   =		hidden_size if n_embed is None else n_embed
        A__		   =		num_hidden_layers
        A__		   =		num_attention_heads
        A__		   =		layer_norm_epsilon
        A__		   =		initializer_range
        A__		   =		use_cache
        A__		   =		hidden_dropout
        A__		   =		attention_dropout

        A__		   =		bos_token_id
        A__		   =		eos_token_id
        A__		   =		num_attention_heads if num_kv_heads is None else num_kv_heads
        A__		   =		alibi
        A__		   =		new_decoder_architecture
        A__		   =		multi_query  # Ignored when new_decoder_architecture is True
        A__		   =		parallel_attn
        A__		   =		bias

        super().__init__(bos_token_id=__lowerCamelCase,eos_token_id=__lowerCamelCase,**__lowerCamelCase					)



 @property
 def 							UpperCamelCase     (				self					):
        return self.hidden_size // self.num_attention_heads




 @property
 def 							UpperCamelCase     (				self					):
        return not self.alibi












import math


def       UpperCamelCase__(			UpperCamelCase__     :			int    )->list:
       A__		   =		[True] * n
       A__		   =		False
       A__		   =		False
       A__		   =		True

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

       A__		   =		[2]

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

       return primes


def       UpperCamelCase__(			UpperCamelCase__     :			int = 99_99_66_66_33_33    )->int:
       A__		   =		math.floor(math.sqrt(UpperCamelCase__    )    ) + 1_00
       A__		   =		prime_sieve(UpperCamelCase__    )

       A__		   =		0
       A__		   =		0
       A__		   =		primes[prime_index]

       while (last_prime**2) <= limit:
              A__		   =		primes[prime_index + 1]

              A__		   =		last_prime**2
              A__		   =		next_prime**2

              # Get numbers divisible by lps(current)
              A__		   =		lower_bound + last_prime
              while upper_bound > current <= limit:
                     matches_sum += current
                     current += last_prime

              # Reset the upper_bound
              while (upper_bound - next_prime) > limit:
                     upper_bound -= next_prime

              # Add the numbers divisible by ups(current)
              A__		   =		upper_bound - next_prime
              while current > lower_bound:
                     matches_sum += current
                     current -= next_prime

              # Remove the numbers divisible by both ups and lps
              A__		   =		0
              while upper_bound > current <= limit:
                     if current <= lower_bound:
                            # Increment the current number
                            current += last_prime * next_prime
                            continue

                     if current > limit:
                            break

                     # Remove twice since it was added by both ups and lps
                     matches_sum -= current * 2

                     # Increment the current number
                     current += last_prime * next_prime

              # Setup for next pair
              A__		   =		next_prime
              prime_index += 1

       return matches_sum


if __name__ == "__main__":
       print(solution())





