
'''simple docstring'''





from typing import List, Union

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


a__						:				Any           =    logging.get_logger(__name__)

a__						:				Any           =    {
    "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/config.json",
    # See all LED models at https://huggingface.co/models?filter=led
}


class 	UpperCamelCase__					(      SCREAMING_SNAKE_CASE):
 UpperCAmelCase__  			=   'led'
 UpperCAmelCase__  			=   {
     'num_attention_heads': 'encoder_attention_heads',
     'hidden_size': 'd_model',
     'attention_probs_dropout_prob': 'attention_dropout',
     'initializer_range': 'init_std',
 }






 def __init__(     self					:Any		,			_A					:Optional[Any]=50_265		,			_A					:Any=16_384		,			_A					:Dict=1_024		,			_A					:List[Any]=12		,			_A					:List[Any]=4_096		,			_A					:Optional[Any]=16		,			_A					:Any=12		,			_A					:Optional[Any]=4_096		,			_A					:int=16		,			_A					:Union[str, Any]=0.0		,			_A					:Dict=0.0		,			_A					:Union[str, Any]=True		,			_A					:List[str]=True		,			_A					:List[str]="gelu"		,			_A					:Optional[int]=1_024		,			_A					:Tuple=0.1		,			_A					:List[Any]=0.0		,			_A					:Union[str, Any]=0.0		,			_A					:List[str]=0.02		,			_A					:str=2		,			_A					:Optional[Any]=0.0		,			_A					:List[str]=1		,			_A					:str=0		,			_A					:int=2		,			_A					:Union[List[int], int] = 512		,			**_A					:Optional[int]		,			)			->     Dict:







       '''simple docstring'''



       __A    		=     vocab_size
       __A    		=     max_encoder_position_embeddings
       __A    		=     max_decoder_position_embeddings
       __A    		=     d_model
       __A    		=     encoder_ffn_dim
       __A    		=     encoder_layers
       __A    		=     encoder_attention_heads
       __A    		=     decoder_ffn_dim
       __A    		=     decoder_layers
       __A    		=     decoder_attention_heads
       __A    		=     dropout
       __A    		=     attention_dropout
       __A    		=     activation_dropout
       __A    		=     activation_function
       __A    		=     init_std
       __A    		=     encoder_layerdrop
       __A    		=     decoder_layerdrop
       __A    		=     classifier_dropout
       __A    		=     use_cache
       __A    		=     encoder_layers
       __A    		=     attention_window

       super().__init__(
           pad_token_id=_A		,			bos_token_id=_A		,			eos_token_id=_A		,			is_encoder_decoder=_A		,			decoder_start_token_id=_A		,			**_A		,			)








'''simple docstring'''





from __future__ import annotations





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     tuple[float, float]:







      """simple docstring"""
      assert (
          c % greatest_common_divisor(UpperCAmelCase ,					UpperCAmelCase		) == 0
      )  # greatest_common_divisor(a,b) function implemented below
      ((__A)		, (__A)		, (__A))    		=     extended_gcd(UpperCAmelCase ,					UpperCAmelCase		)  # extended_gcd(a,b) function implemented below
      __A    		=     c / d
      return (r * x, r * y)





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase = 2		)->     None:







      """simple docstring"""
      ((__A)		, (__A))    		=     diophantine(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)  # Initial value
      __A    		=     greatest_common_divisor(UpperCAmelCase ,					UpperCAmelCase		)
      __A    		=     a // d
      __A    		=     b // d

      for i in range(UpperCAmelCase		):
            __A    		=     xa + i * q
            __A    		=     ya - i * p
            print(UpperCAmelCase ,					UpperCAmelCase		)





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase		)->     int:







      """simple docstring"""
      if a < b:
            __A		, __A    		=     b, a

      while a % b != 0:
            __A		, __A    		=     b, a % b

      return b





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase		)->     tuple[int, int, int]:







      """simple docstring"""
      assert a >= 0 and b >= 0

      if b == 0:
            __A		, __A		, __A    		=     a, 1, 0
      else:
            ((__A)		, (__A)		, (__A))    		=     extended_gcd(UpperCAmelCase ,					a % b		)
            __A    		=     q
            __A    		=     p - q * (a // b)

      assert a % d == 0 and b % d == 0
      assert d == a * x + b * y

      return (d, x, y)


if __name__ == "__main__":
 from doctest import testmod

 testmod(name="diophantine", verbose=True)
 testmod(name="diophantine_all_soln", verbose=True)
 testmod(name="extended_gcd", verbose=True)
 testmod(name="greatest_common_divisor", verbose=True)






