


from itertools import product
def        UpperCamelCase_(				_A   :str				,     _A   :Any  )->		list[int]:
			UpperCamelCase__					=       sides_number
			UpperCamelCase__					=       max_face_number * dice_number
			UpperCamelCase__					=       [0] * (max_total + 1)

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

			return totals_frequencies
def        UpperCamelCase_(				)->		float:
			UpperCamelCase__					=       total_frequency_distribution(
			    sides_number=4				,     dice_number=9  )
			UpperCamelCase__					=       total_frequency_distribution(
			    sides_number=6				,     dice_number=6  )

			UpperCamelCase__					=       0
			UpperCamelCase__					=       9
			UpperCamelCase__					=       4 * 9
			UpperCamelCase__					=       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]  )

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

			UpperCamelCase__					=       round(_A				,     ndigits=7  )

			return rounded_peter_win_probability


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






def        UpperCamelCase_(				_A   :List[str]				,     _A   :Tuple				,     _A   :Any				,     _A   :Tuple				,     _A   :Optional[int]				,     _A   :str  )->		List[str]:
			if index == r:
						for j in range(_A  ):
									print(data[j]				,     end=" "  )
						print(" "  )
						return
			#  When no more elements are there to put in data[]
			if i >= n:
						return
			# current is included, put next at next location
			UpperCamelCase__					=       arr[i]
			combination_util(_A				,     _A				,     _A				,     index + 1				,     _A				,     i + 1  )
			# current is excluded, replace it with
			# next (Note that i+1 is passed, but
			# index is not changed)
			combination_util(_A				,     _A				,     _A				,     _A				,     _A				,     i + 1  )
			# The main function that prints all combinations
			# of size r in arr[] of size n. This function
			# mainly uses combinationUtil()
def        UpperCamelCase_(				_A   :Dict				,     _A   :Optional[Any]				,     _A   :Union[str, Any]  )->		Optional[int]:
			# A temporary array to store all combination one by one
			UpperCamelCase__					=       [0] * r
			# Print all combination using temporary array 'data[]'
			combination_util(_A				,     _A				,     _A				,     0				,     _A				,     0  )


if __name__ == "__main__":
						# Driver code to check the function above
						__UpperCamelCase    		=       [1_0, 2_0, 3_0, 4_0, 5_0]
						print_combination(arr, len(arr), 3)
						# This code is contributed by Ambuj sahu


