



'''simple docstring'''



from __future__ import annotations

_lowercase       :						List[str]						=[2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]






class 			_SCREAMING_SNAKE_CASE				:



			def __init__(     self		:						str    ,			__UpperCamelCase		:						int			)      ->      None:
							"""simple docstring"""





							snake_case__      :   int      =    -1
							snake_case__      :   int      =    -1
							snake_case__      :   list[int]      =    [-1] * length
							snake_case__      :   Node | None      =    None
							snake_case__      :   Node | None      =    None







			def __repr__(     self		:						Union[str, Any]			)      ->      str:
							"""simple docstring"""





							return F'''Node(min_value={self.minn} max_value={self.maxx})'''



def 							__UpperCAmelCase				(				UpperCamelCase__				:list[int]			)		->						Node | None:
				snake_case__      :   str      =    Node(len(UpperCamelCase__			)			)
				snake_case__  ,      snake_case__      :   str      =    min(UpperCamelCase__			), max(UpperCamelCase__			)
				# Leaf node case where the node contains only one unique value
				if root.minn == root.maxx:
								return root
				snake_case__      :   List[str]      =    (root.minn + root.maxx) // 2

				snake_case__      :   list[int]      =    []
				snake_case__      :   list[int]      =    []

				for index, num in enumerate(UpperCamelCase__			):
								if num <= pivot:
												left_arr.append(UpperCamelCase__			)
								else:
												right_arr.append(UpperCamelCase__			)
								snake_case__      :   Tuple      =    len(UpperCamelCase__			)
				snake_case__      :   Optional[Any]      =    build_tree(UpperCamelCase__			)
				snake_case__      :   Optional[int]      =    build_tree(UpperCamelCase__			)
				return root


def 							__UpperCAmelCase				(				UpperCamelCase__				:Node | None   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						int:
				if index < 0 or node is None:
								return 0
				# Leaf node cases
				if node.minn == node.maxx:
								return index + 1 if node.minn == num else 0
				snake_case__      :   Any      =    (node.minn + node.maxx) // 2
				if num <= pivot:
								# go the left subtree and map index to the left subtree
								return rank_till_index(node.left   ,				UpperCamelCase__   ,				node.map_left[index] - 1			)
				else:
								# go to the right subtree and map index to the right subtree
								return rank_till_index(node.right   ,				UpperCamelCase__   ,				index - node.map_left[index]			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Node | None   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						int:
				if start > end:
								return 0
				snake_case__      :   int      =    rank_till_index(UpperCamelCase__   ,				UpperCamelCase__   ,				UpperCamelCase__			)
				snake_case__      :   Dict      =    rank_till_index(UpperCamelCase__   ,				UpperCamelCase__   ,				start - 1			)
				return rank_till_end - rank_before_start


def 							__UpperCAmelCase				(				UpperCamelCase__				:Node | None   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						int:
				if index > (end - start) or start > end or node is None:
								return -1
				# Leaf node case
				if node.minn == node.maxx:
								return node.minn
				# Number of elements in the left subtree in interval [start, end]
				snake_case__      :   str      =    node.map_left[end] - (
				    node.map_left[start - 1] if start else 0
				)
				if num_elements_in_left_tree > index:
								return quantile(
								    node.left   ,				UpperCamelCase__   ,				(node.map_left[start - 1] if start else 0)   ,				node.map_left[end] - 1   ,				)
				else:
								return quantile(
								    node.right   ,				index - num_elements_in_left_tree   ,				start - (node.map_left[start - 1] if start else 0)   ,				end - node.map_left[end]   ,				)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Node | None   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						int:
				if (
				    start > end
				    or node is None
				    or start_num > end_num
				    or node.minn > end_num
				    or node.maxx < start_num
				):
								return 0
				if start_num <= node.minn and node.maxx <= end_num:
								return end - start + 1
				snake_case__      :   List[str]      =    range_counting(
				    node.left   ,				(node.map_left[start - 1] if start else 0)   ,				node.map_left[end] - 1   ,				UpperCamelCase__   ,				UpperCamelCase__   ,				)
				snake_case__      :   Tuple      =    range_counting(
				    node.right   ,				start - (node.map_left[start - 1] if start else 0)   ,				end - node.map_left[end]   ,				UpperCamelCase__   ,				UpperCamelCase__   ,				)
				return left + right


if __name__ == "__main__":
				import doctest

				doctest.testmod()










from __future__ import annotations

import random







class 		__UpperCAmelCase:





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     6

     def __init__(   self			:							int     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							list(range(1    ,					Dice.NUM_SIDES + 1     )     )






     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      List[str]:






         """simple docstring"""
         return random.choice(self.sides     )






def 							__lowerCAmelCase			(UpperCAmelCase_ ,     UpperCAmelCase_ = 2		):
    a__  			=							[Dice() for i in range(UpperCAmelCase_		)]
    a__  			=							[0] * (len(UpperCAmelCase_		) * Dice.NUM_SIDES + 1)
    for _ in range(UpperCAmelCase_		):
        count_of_sum[sum(dice.roll() for dice in dices		)] += 1
    a__  			=							[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()






