
from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase_ 				=			logging.get_logger(__name__)

lowercase_ 				=			{
    """facebook/xlm-roberta-xl""": """https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json""",
    """facebook/xlm-roberta-xxl""": """https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json""",
    # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl
}





class     __UpperCamelCase (							lowerCAmelCase__       ):






     """simple docstring"""







     lowerCAmelCase_							   =			'''xlm-roberta-xl'''



     def __init__(				self							:							Optional[int]     ,						_A							:							Optional[Any]=25_0880     ,						_A							:							Tuple=2560     ,						_A							:							Optional[int]=36     ,						_A							:							Dict=32     ,						_A							:							int=1_0240     ,						_A							:							Dict="gelu"     ,						_A							:							Tuple=0.1     ,						_A							:							Tuple=0.1     ,						_A							:							List[Any]=514     ,						_A							:							List[Any]=1     ,						_A							:							Optional[int]=0.02     ,						_A							:							Any=1e-05     ,						_A							:							str=1     ,						_A							:							Tuple=0     ,						_A							:							int=2     ,						_A							:							Dict="absolute"     ,						_A							:							Optional[int]=True     ,						_A							:							int=None     ,						**_A							:							List[Any]     ,						):







       """simple docstring"""




       super().__init__(pad_token_id=_A     ,						bos_token_id=_A     ,						eos_token_id=_A     ,						**_A )
       __SCREAMING_SNAKE_CASE      :	Any					=		vocab_size
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		hidden_size
       __SCREAMING_SNAKE_CASE      :	str					=		num_hidden_layers
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		num_attention_heads
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		hidden_act
       __SCREAMING_SNAKE_CASE      :	Tuple					=		intermediate_size
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		hidden_dropout_prob
       __SCREAMING_SNAKE_CASE      :	int					=		attention_probs_dropout_prob
       __SCREAMING_SNAKE_CASE      :	Any					=		max_position_embeddings
       __SCREAMING_SNAKE_CASE      :	str					=		type_vocab_size
       __SCREAMING_SNAKE_CASE      :	Dict					=		initializer_range
       __SCREAMING_SNAKE_CASE      :	List[str]					=		layer_norm_eps
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		position_embedding_type
       __SCREAMING_SNAKE_CASE      :	Dict					=		use_cache
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		classifier_dropout






class     __UpperCamelCase (							lowerCAmelCase__       ):






     """simple docstring"""







     @property
     def  UpperCAmelCase__							(				self							:							Optional[Any] ):







       """simple docstring"""




       if self.task == "multiple-choice":
         __SCREAMING_SNAKE_CASE      :	List[str]					=		{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
       else:
         __SCREAMING_SNAKE_CASE      :	Tuple					=		{0: '''batch''', 1: '''sequence'''}
       return OrderedDict(
           [
               ('''input_ids''', dynamic_axis),
               ('''attention_mask''', dynamic_axis),
           ] )





"""simple docstring"""






from itertools import product




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_	)						->				list[int]:
  _snake_case   	=      sides_number
  _snake_case   	=      max_face_number * dice_number
  _snake_case   	=      [0] * (max_total + 1)

  _snake_case   	=      1
  _snake_case   	=      range(lowerCAmelCase_  ,						max_face_number + 1	)
  for dice_numbers in product(lowerCAmelCase_  ,						repeat=lowerCAmelCase_	):
    _snake_case   	=      sum(lowerCAmelCase_	)
    totals_frequencies[total] += 1

  return totals_frequencies




def 			snake_case		(		)						->				float:
  _snake_case   	=      total_frequency_distribution(
      sides_number=4  ,						dice_number=9	)
  _snake_case   	=      total_frequency_distribution(
      sides_number=6  ,						dice_number=6	)

  _snake_case   	=      0
  _snake_case   	=      9
  _snake_case   	=      4 * 9
  _snake_case   	=      6
  for peter_total in range(lowerCAmelCase_  ,						max_peter_total + 1	):
    peter_wins_count += peter_totals_frequencies[peter_total] * sum(
        colin_totals_frequencies[min_colin_total:peter_total]	)

  _snake_case   	=      (4**9) * (6**6)
  _snake_case   	=      peter_wins_count / total_games_number

  _snake_case   	=      round(lowerCAmelCase_  ,						ndigits=7	)

  return rounded_peter_win_probability


if __name__ == "__main__":
     print(F"{solution() = }")





