






from itertools import product





def 					lowercase_ (    __snake_case     :							int	,	__snake_case     :							int      )     -> Optional[int]:





				'''simple docstring'''


				snake_case__      :str         =   sides_number
				snake_case__      :Union[str, Any]         =   max_face_number * dice_number
				snake_case__      :Any         =   [0] * (max_total + 1)

				snake_case__      :Tuple         =   1
				snake_case__      :Union[str, Any]         =   range(A__	,	max_face_number + 1      )
				for dice_numbers in product(A__	,	repeat=A__      ):
								snake_case__      :Tuple         =   sum(A__      )
								totals_frequencies[total] += 1

				return totals_frequencies





def 					lowercase_ (    )     -> Optional[int]:





				'''simple docstring'''


				snake_case__      :List[str]         =   total_frequency_distribution(
				    sides_number=4	,	dice_number=9      )
				snake_case__      :Dict         =   total_frequency_distribution(
				    sides_number=6	,	dice_number=6      )

				snake_case__      :int         =   0
				snake_case__      :Optional[int]         =   9
				snake_case__      :Optional[Any]         =   4 * 9
				snake_case__      :int         =   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]      )

				snake_case__      :Tuple         =   (4**9) * (6**6)
				snake_case__      :List[Any]         =   peter_wins_count / total_games_number

				snake_case__      :Union[str, Any]         =   round(A__	,	ndigits=7      )

				return rounded_peter_win_probability


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







from __future__ import annotations


class 					_snake_case						:






	def __init__(		self					,UpperCamelCase       )						->    None:
					snake_case__      :Union[str, Any]         =   data
					snake_case__      :Node | None         =   None
					snake_case__      :Node | None         =   None





def 					lowercase_ (    __snake_case     :							Node | None      )     -> None:  # In Order traversal of the tree





				'''simple docstring'''


				if tree:
								display(tree.left      )
								print(tree.data      )
								display(tree.right      )





def 					lowercase_ (    __snake_case     :							Node | None      )     -> int:





				'''simple docstring'''


				return 1 + max(depth_of_tree(tree.left      )	,	depth_of_tree(tree.right      )      ) if tree else 0





def 					lowercase_ (    __snake_case     :							Node      )     -> bool:





				'''simple docstring'''


				if not tree:
								return True
				if tree.left and tree.right:
								return is_full_binary_tree(tree.left      ) and is_full_binary_tree(tree.right      )
				else:
								return not tree.left and not tree.right





def 					lowercase_ (    )     -> None:  # Main function for testing.





				'''simple docstring'''


				snake_case__      :Dict         =   Node(1      )
				snake_case__      :int         =   Node(2      )
				snake_case__      :Optional[Any]         =   Node(3      )
				snake_case__      :Tuple         =   Node(4      )
				snake_case__      :str         =   Node(5      )
				snake_case__      :Optional[Any]         =   Node(6      )
				snake_case__      :List[Any]         =   Node(7      )
				snake_case__      :List[str]         =   Node(8      )
				snake_case__      :Tuple         =   Node(9      )

				print(is_full_binary_tree(__snake_case      )      )
				print(depth_of_tree(__snake_case      )      )
				print("Tree is: "      )
				display(__snake_case      )


if __name__ == "__main__":
	main()