


'''simple docstring'''





SCREAMING_SNAKE_CASE       :		Any         =				{0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

SCREAMING_SNAKE_CASE       :		List[Any]         =				{0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}




def     UpperCamelCase    (      _a       ,		_a       ,		_a		)					->							Any:
     '''simple docstring'''





     lowercase_       :List[str]     =       True
     lowercase_       :List[str]     =       []

     for neighbour in graph[vert]:
          if not visited[neighbour]:
               order += topology_sort(_lowercase       ,		_lowercase       ,		_lowercase		)

     order.append(_lowercase		)

     return order




def     UpperCamelCase    (      _a       ,		_a       ,		_a		)					->							Union[str, Any]:
     '''simple docstring'''





     lowercase_       :Optional[Any]     =       True
     lowercase_       :str     =       [vert]

     for neighbour in reversed_graph[vert]:
          if not visited[neighbour]:
               component += find_components(_lowercase       ,		_lowercase       ,		_lowercase		)

     return component




def     UpperCamelCase    (      _a		)					->							List[Any]:
     '''simple docstring'''





     lowercase_       :List[Any]     =       len(_lowercase		) * [False]
     lowercase_       :Optional[Any]     =       {vert: [] for vert in range(len(_lowercase		)		)}

     for vert, neighbours in graph.items():
          for neighbour in neighbours:
               reversed_graph[neighbour].append(_lowercase		)

     lowercase_       :List[Any]     =       []
     for i, was_visited in enumerate(_lowercase		):
          if not was_visited:
               order += topology_sort(_lowercase       ,		_lowercase       ,		_lowercase		)

     lowercase_       :int     =       []
     lowercase_       :str     =       len(_lowercase		) * [False]

     for i in range(len(_lowercase		)		):
          lowercase_       :List[Any]     =       order[len(_lowercase		) - i - 1]
          if not visited[vert]:
               lowercase_       :List[str]     =       find_components(_lowercase       ,		_lowercase       ,		_lowercase		)
               components_list.append(_lowercase		)

     return components_list





import math

SCREAMING_SNAKE_CASE       :		List[str]         =				10
SCREAMING_SNAKE_CASE       :		Dict         =				7
SCREAMING_SNAKE_CASE       :		int         =				BALLS_PER_COLOUR * NUM_COLOURS




def     UpperCamelCase    (      _a = 2_0		)					->							str:
     '''simple docstring'''





     lowercase_       :List[str]     =       math.comb(_a       ,		_a		)
     lowercase_       :Tuple     =       math.comb(NUM_BALLS - BALLS_PER_COLOUR       ,		_a		)

     lowercase_       :Dict     =       NUM_COLOURS * (1 - missing_colour / total)

     return f"{result:.9f}"


if __name__ == "__main__":
   print(solution(20))

