




'''simple docstring'''





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_   ,	UpperCAmelCase_						):
    if hue < 0 or hue > 360:
        raise Exception("""hue should be between 0 and 360"""						)

    if saturation < 0 or saturation > 1:
        raise Exception("""saturation should be between 0 and 1"""						)

    if value < 0 or value > 1:
        raise Exception("""value should be between 0 and 1"""						)

    _a				:							int							       =      value * saturation
    _a				:							Any							       =      hue / 60
    _a				:							str							       =      chroma * (1 - abs(hue_section % 2 - 1						))
    _a				:							Union[str, Any]							       =      value - chroma

    if hue_section >= 0 and hue_section <= 1:
        _a				:							Any							       =      round(255 * (chroma + match_value)						)
        _a				:							Optional[Any]							       =      round(255 * (second_largest_component + match_value)						)
        _a				:							int							       =      round(255 * (match_value)						)
    elif hue_section > 1 and hue_section <= 2:
        _a				:							List[Any]							       =      round(255 * (second_largest_component + match_value)						)
        _a				:							Tuple							       =      round(255 * (chroma + match_value)						)
        _a				:							Optional[int]							       =      round(255 * (match_value)						)
    elif hue_section > 2 and hue_section <= 3:
        _a				:							int							       =      round(255 * (match_value)						)
        _a				:							Any							       =      round(255 * (chroma + match_value)						)
        _a				:							str							       =      round(255 * (second_largest_component + match_value)						)
    elif hue_section > 3 and hue_section <= 4:
        _a				:							Union[str, Any]							       =      round(255 * (match_value)						)
        _a				:							Dict							       =      round(255 * (second_largest_component + match_value)						)
        _a				:							Union[str, Any]							       =      round(255 * (chroma + match_value)						)
    elif hue_section > 4 and hue_section <= 5:
        _a				:							int							       =      round(255 * (second_largest_component + match_value)						)
        _a				:							Dict							       =      round(255 * (match_value)						)
        _a				:							Dict							       =      round(255 * (chroma + match_value)						)
    else:
        _a				:							Dict							       =      round(255 * (chroma + match_value)						)
        _a				:							Tuple							       =      round(255 * (match_value)						)
        _a				:							int							       =      round(255 * (second_largest_component + match_value)						)

    return [red, green, blue]





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_   ,	UpperCAmelCase_						):
    if red < 0 or red > 255:
        raise Exception("""red should be between 0 and 255"""						)

    if green < 0 or green > 255:
        raise Exception("""green should be between 0 and 255"""						)

    if blue < 0 or blue > 255:
        raise Exception("""blue should be between 0 and 255"""						)

    _a				:							Dict							       =      red / 255
    _a				:							Optional[Any]							       =      green / 255
    _a				:							Tuple							       =      blue / 255
    _a				:							Union[str, Any]							       =      max(UpperCAmelCase_   ,	UpperCAmelCase_   ,	UpperCAmelCase_						)
    _a				:							Tuple							       =      value - min(UpperCAmelCase_   ,	UpperCAmelCase_   ,	UpperCAmelCase_						)
    _a				:							Optional[int]							       =      0 if value == 0 else chroma / value

    if chroma == 0:
        _a				:							str							       =      0.0
    elif value == float_red:
        _a				:							str							       =      60 * (0 + (float_green - float_blue) / chroma)
    elif value == float_green:
        _a				:							str							       =      60 * (2 + (float_blue - float_red) / chroma)
    else:
        _a				:							Tuple							       =      60 * (4 + (float_red - float_green) / chroma)

    _a				:							List[str]							       =      (hue + 360) % 360

    return [hue, saturation, value]





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_						):
    _a				:							Optional[int]							       =      abs(hsv_a[0] - hsv_a[0]						) < 0.2
    _a				:							List[str]							       =      abs(hsv_a[1] - hsv_a[1]						) < 0.002
    _a				:							int							       =      abs(hsv_a[2] - hsv_a[2]						) < 0.002

    return check_hue and check_saturation and check_value





from math import factorial




def        __UpperCamelCase     (      _A					:							Union[str, Any]      ,  _A					:							Tuple		)				->Any:



							"""simple docstring"""
							return factorial(_A		) / (factorial(_A		) * factorial(n - r		))




def        __UpperCamelCase     (      )				->Any:



							"""simple docstring"""
							lowerCamelCase_								=0

							for i in range(1      ,  101		):
														for j in range(1      ,  i + 1		):
																					if combinations(_A      ,  _A		) > 1E6:
																												total += 1
							return total


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