






"""simple docstring"""

def 		__lowerCamelCase	(  __UpperCamelCase      ,       __UpperCamelCase = False       )						->    bool:

		"""simple docstring"""







		if n == 2:
				return True
		if not n % 2 or n < 2:
				return False
		if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
				return False
		if n > 3317044064679887385961981 and not allow_probable:
				raise ValueError(
				    "Warning: upper bound of deterministic test is exceeded. "
				    "Pass allow_probable=True to allow probabilistic test. "
				    "A return value of True indicates a probable prime."       )
		# array bounds provided by analysis
		lowerCAmelCase_   :							Optional[int]									=			[
		    2047,
		    1373653,
		    25326001,
		    3215031751,
		    2152302898747,
		    3474749660383,
		    341550071728321,
		    1,
		    3825123056546413051,
		    1,
		    1,
		    318665857834031151167461,
		    3317044064679887385961981,
		]

		lowerCAmelCase_   :							Union[str, Any]									=			[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
		for idx, _p in enumerate(__A      ,       1       ):
				if n < _p:
						# then we have our last prime to check
						lowerCAmelCase_   :							int									=			primes[:idx]
						break
		lowerCAmelCase_				,	lowerCAmelCase_   :							Any									=			n - 1, 0
		# break up n -1 into a power of 2 (s) and
		# remaining odd component
		# essentially, solve for d * 2 ** s == n - 1
		while d % 2 == 0:
				d //= 2
				s += 1
		for prime in plist:
				lowerCAmelCase_   :							Any									=			False
				for r in range(__A       ):
						lowerCAmelCase_   :							Optional[Any]									=			pow(__A      ,       d * 2**r      ,       __A       )
						# see article for analysis explanation for m
						if (r == 0 and m == 1) or ((m + 1) % n == 0):
								lowerCAmelCase_   :							Optional[int]									=			True
								# this loop will not determine compositeness
								break
				if pr:
						continue
				# if pr is False, then the above loop never evaluated to true,
				# and the n MUST be composite
				return False
		return True

def 		__lowerCamelCase	(  )						->    None:

		"""simple docstring"""







		assert not miller_rabin(561       )
		assert miller_rabin(563       )
		# 2047

		assert not miller_rabin(838201       )
		assert miller_rabin(838207       )
		# 1_373_653

		assert not miller_rabin(17316001       )
		assert miller_rabin(17316017       )
		# 25_326_001

		assert not miller_rabin(3078386641       )
		assert miller_rabin(3078386653       )
		# 3_215_031_751

		assert not miller_rabin(1713045574801       )
		assert miller_rabin(1713045574819       )
		# 2_152_302_898_747

		assert not miller_rabin(2779799728307       )
		assert miller_rabin(2779799728327       )
		# 3_474_749_660_383

		assert not miller_rabin(113850023909441       )
		assert miller_rabin(113850023909527       )
		# 341_550_071_728_321

		assert not miller_rabin(1275041018848804351       )
		assert miller_rabin(1275041018848804391       )
		# 3_825_123_056_546_413_051

		assert not miller_rabin(79666464458507787791867       )
		assert miller_rabin(79666464458507787791951       )
		# 318_665_857_834_031_151_167_461

		assert not miller_rabin(552840677446647897660333       )
		assert miller_rabin(552840677446647897660359       )
		# 3_317_044_064_679_887_385_961_981
		# upper limit for probabilistic test


if __name__ == "__main__":
					test_miller_rabin()






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


snake_case_ : Any    		=       logging.get_logger(__name__)

snake_case_ : Optional[Any]    		=       {
    "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 __snake_case			(			a		):
   UpperCAmelCase__  :    Optional[Any]          =  '''falcon'''
   UpperCAmelCase__  :    List[Any]          =  ['''past_key_values''']







   def __init__(      self		:						Union[str, Any]					,						_snake_case		:						List[str]=65024					,						_snake_case		:						int=4544					,						_snake_case		:						int=32					,						_snake_case		:						Any=71					,						_snake_case		:						int=1e-5					,						_snake_case		:						Dict=0.0_2					,						_snake_case		:						int=True					,						_snake_case		:						List[Any]=0.0					,						_snake_case		:						Tuple=0.0					,						_snake_case		:						int=None					,						_snake_case		:						Tuple=False					,						_snake_case		:						Any=False					,						_snake_case		:						str=True					,						_snake_case		:						Any=True					,						_snake_case		:						List[str]=False					,						_snake_case		:						Tuple=11					,						_snake_case		:						Dict=11					,						**_snake_case		:						Optional[int]					,						):

        """simple docstring"""


        UpperCAmelCase_          =							vocab_size
        # Backward compatibility with n_embed kwarg
        UpperCAmelCase_          =							kwargs.pop('''n_embed'''					,						_snake_case)
        UpperCAmelCase_          =							hidden_size if n_embed is None else n_embed
        UpperCAmelCase_          =							num_hidden_layers
        UpperCAmelCase_          =							num_attention_heads
        UpperCAmelCase_          =							layer_norm_epsilon
        UpperCAmelCase_          =							initializer_range
        UpperCAmelCase_          =							use_cache
        UpperCAmelCase_          =							hidden_dropout
        UpperCAmelCase_          =							attention_dropout

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

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







   @property
   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


        return self.hidden_size // self.num_attention_heads







   @property
   def lowerCamelCase						(      self		:						Union[str, Any]):

        """simple docstring"""


        return not self.alibi






