


'''simple docstring'''






from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

__A   :    Optional[int]											= TypeVar("T")






class   __snake_case			(  Generic[T]):







    """simple docstring"""



    def __init__(  self       :    Optional[int]       ,		lowerCamelCase       :    Optional[int]						)  ->    List[Any]:
      lowerCAmelCase_     : List[Any]     =  data
      lowerCAmelCase_     : Union[str, Any]     =  None





    def __str__(  self       :    Tuple						)  ->    Optional[Any]:
      return F'{self.data}'







class   __snake_case			(  Generic[T]):







    """simple docstring"""



    def __init__(  self       :    Any						)  ->    str:
      lowerCAmelCase_     : List[str]     =  None

    def __iter__(  self       :    Tuple						)  ->    Dict:
      lowerCAmelCase_     : Tuple     =  self.top
      while node:
        yield node.data
        lowerCAmelCase_     : List[Any]     =  node.next

    def __str__(  self       :    Dict						)  ->    int:
      return "->".join([str(lowerCamelCase						) for item in self]						)

    def __len__(  self       :    str						)  ->    Optional[Any]:
      return len(tuple(iter(self						)						)						)

    def __lowercase  (  self       :    Union[str, Any]						)  ->    str:
      return self.top is None

    def __lowercase  (  self       :    Optional[Any]       ,		lowerCamelCase       :    Any						)  ->    int:
      lowerCAmelCase_     : str     =  Node(lowerCamelCase						)
      if not self.is_empty():
        lowerCAmelCase_     : Tuple     =  self.top
      lowerCAmelCase_     : int     =  node

    def __lowercase  (  self       :    Optional[Any]						)  ->    Dict:
      if self.is_empty():
        raise IndexError("""pop from empty stack"""						)
      assert isinstance(self.top       ,		lowerCamelCase						)
      lowerCAmelCase_     : List[str]     =  self.top
      lowerCAmelCase_     : List[Any]     =  self.top.next
      return pop_node.data

    def __lowercase  (  self       :    Optional[int]						)  ->    Union[str, Any]:
      if self.is_empty():
        raise IndexError("""peek from empty stack"""						)

      assert self.top is not None
      return self.top.data





    def __lowercase  (  self       :    Union[str, Any]						)  ->    str:
      lowerCAmelCase_     : List[str]     =  None


if __name__ == "__main__":
  from doctest import testmod

  testmod()





import math

__magic_name__  							=	10
__magic_name__  							=	7
__magic_name__  							=	BALLS_PER_COLOUR * NUM_COLOURS





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase = 20				):
    snake_case__    =					math.comb(__lowerCAmelCase     ,		__lowerCAmelCase				)
    snake_case__    =					math.comb(NUM_BALLS - BALLS_PER_COLOUR     ,		__lowerCAmelCase				)

    snake_case__    =					NUM_COLOURS * (1 - missing_colour / total)

    return F"""{result:.9f}"""


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



