





from __future__ import annotations

import random





class 	lowerCAmelCase__:






       '''simple docstring'''


       __snake_case       	=			6




       def __init__(					self							)	->   int:
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							list(range(1			,  Dice.NUM_SIDES + 1							)							)







       def 			UpperCamelCase_	(					self							)	->   Optional[int]:
            return random.choice(self.sides							)






def 			lowerCamelCase__	(__lowerCamelCase,				__lowerCamelCase = 2		):
     _SCREAMING_SNAKE_CASE				:		Tuple  			=							[Dice() for i in range(__lowerCamelCase		)]
     _SCREAMING_SNAKE_CASE				:		List[Any]  			=							[0] * (len(__lowerCamelCase		) * Dice.NUM_SIDES + 1)
     for _ in range(__lowerCamelCase		):
          count_of_sum[sum(dice.roll() for dice in dices		)] += 1
     _SCREAMING_SNAKE_CASE				:		str  			=							[round((count * 100) / num_throws,				2		) for count in count_of_sum]
     return probability[num_dice:]  # remove probability of sums that never appear


if __name__ == "__main__":
       import doctest

       doctest.testmod()





'''simple docstring'''


from dataclasses import dataclass
from typing import Callable, Optional

import datasets

@dataclass
class 			A    (		datasets.BuilderConfig    ):
							lowercase_							=				None
							lowercase_							=				None
							lowercase_							=				None







							def    __lowerCAmelCase			(  self       :  Dict					)			->							List[str]:


														"""simple docstring"""


														assert self.generator is not None, "generator must be specified"

														if self.gen_kwargs is None:
																					_a	     =				{}



class 			A    (		datasets.GeneratorBasedBuilder    ):
							lowercase_							=				GeneratorConfig







							def    __lowerCAmelCase			(  self       :  Any					)			->							List[str]:


														"""simple docstring"""


														return datasets.DatasetInfo(features=self.config.features					)







							def    __lowerCAmelCase			(  self       :  Dict							,			lowerCAmelCase_       :  Optional[int]					)			->							Optional[Any]:


														"""simple docstring"""


														return [datasets.SplitGenerator(name=datasets.Split.TRAIN							,			gen_kwargs=self.config.gen_kwargs					)]







							def    __lowerCAmelCase			(  self       :  str							,			**lowerCAmelCase_       :  int					)			->							List[str]:


														"""simple docstring"""


														for idx, ex in enumerate(self.config.generator(**lowerCAmelCase_					)					):
																					yield idx, ex

