





"""simple docstring"""





from itertools import product
def 					__A  (_SCREAMING_SNAKE_CASE	,  _SCREAMING_SNAKE_CASE     )   ->list[int]:





  """simple docstring"""


  lowerCAmelCase__     :int											=				sides_number
  lowerCAmelCase__     :Dict											=				max_face_number * dice_number
  lowerCAmelCase__     :Optional[int]											=				[0] * (max_total + 1)

  lowerCAmelCase__     :Dict											=				1
  lowerCAmelCase__     :str											=				range(_SCREAMING_SNAKE_CASE	,  max_face_number + 1     )
  for dice_numbers in product(_SCREAMING_SNAKE_CASE	,  repeat=_SCREAMING_SNAKE_CASE     ):
    lowerCAmelCase__     :List[str]											=				sum(_SCREAMING_SNAKE_CASE     )
    totals_frequencies[total] += 1

  return totals_frequencies
def 					__A  ()   ->float:





  """simple docstring"""


  lowerCAmelCase__     :int											=				total_frequency_distribution(
      sides_number=4	,  dice_number=9     )
  lowerCAmelCase__     :Union[str, Any]											=				total_frequency_distribution(
      sides_number=6	,  dice_number=6     )

  lowerCAmelCase__     :Union[str, Any]											=				0
  lowerCAmelCase__     :Union[str, Any]											=				9
  lowerCAmelCase__     :List[Any]											=				4 * 9
  lowerCAmelCase__     :Optional[int]											=				6
  for peter_total in range(_SCREAMING_SNAKE_CASE	,  max_peter_total + 1     ):
    peter_wins_count += peter_totals_frequencies[peter_total] * sum(
        colin_totals_frequencies[min_colin_total:peter_total]     )

  lowerCAmelCase__     :Tuple											=				(4**9) * (6**6)
  lowerCAmelCase__     :List[str]											=				peter_wins_count / total_games_number

  lowerCAmelCase__     :List[str]											=				round(_SCREAMING_SNAKE_CASE	,  ndigits=7     )

  return rounded_peter_win_probability


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



'''simple docstring'''



from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available



@dataclass
class 				_snake_case					(   a_			):
  SCREAMING_SNAKE_CASE			:       Union[List[np.ndarray], torch.FloatTensor]


try:
     if not (is_transformers_available() and is_torch_available()):
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
     from .pipeline_text_to_video_synth import TextToVideoSDPipeline
     from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
     from .pipeline_text_to_video_zero import TextToVideoZeroPipeline





