


'''simple docstring'''

from itertools import product

def 							__magic_name__(  lowerCamelCase, lowerCamelCase):
						__lowerCAmelCase											= sides_number
						__lowerCAmelCase											= max_face_number * dice_number
						__lowerCAmelCase											= [0] * (max_total + 1)

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

						return totals_frequencies

def 							__magic_name__(  ):
						__lowerCAmelCase											= total_frequency_distribution(
						    sides_number=4, dice_number=9)
						__lowerCAmelCase											= total_frequency_distribution(
						    sides_number=6, dice_number=6)

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

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

						__lowerCAmelCase											= round(a__, ndigits=7)

						return rounded_peter_win_probability


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



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A     :	Optional[int]    = {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	int    = ['WhisperTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	str    = [
					    'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'WhisperForConditionalGeneration',
					    'WhisperModel',
					    'WhisperPreTrainedModel',
					    'WhisperForAudioClassification',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	Tuple    = [
					    'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFWhisperForConditionalGeneration',
					    'TFWhisperModel',
					    'TFWhisperPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	int    = [
					    'FlaxWhisperForConditionalGeneration',
					    'FlaxWhisperModel',
					    'FlaxWhisperPreTrainedModel',
					    'FlaxWhisperForAudioClassification',
					]


if TYPE_CHECKING:
					from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
					from .feature_extraction_whisper import WhisperFeatureExtractor
					from .processing_whisper import WhisperProcessor
					from .tokenization_whisper import WhisperTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_whisper_fast import WhisperTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_whisper import (
										    WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    WhisperForAudioClassification,
										    WhisperForConditionalGeneration,
										    WhisperModel,
										    WhisperPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_whisper import (
										    TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFWhisperForConditionalGeneration,
										    TFWhisperModel,
										    TFWhisperPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_whisper import (
										    FlaxWhisperForAudioClassification,
										    FlaxWhisperForConditionalGeneration,
										    FlaxWhisperModel,
										    FlaxWhisperPreTrainedModel,
										)

else:
					import sys

					A     :	Tuple    = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)