



def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case     )  ->  int:






      '''simple docstring'''







      return len_board * len_board_column * row + column







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	)  ->  bool:






      '''simple docstring'''







      if board[row][column] != word[word_index]:
            return False

      if word_index == len(__snake_case     ) - 1:
            return True

      UpperCAmelCase_	:						Union[str, Any]					   =		[(0, 1), (0, -1), (-1, 0), (1, 0)]
      UpperCAmelCase_	:						Optional[Any]					   =		len(__snake_case     )
      UpperCAmelCase_	:						Union[str, Any]					   =		len(board[0]     )
      for direction in traverts_directions:
            UpperCAmelCase_	:						List[Any]					   =		row + direction[0]
            UpperCAmelCase_	:						List[str]					   =		column + direction[1]
            if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
                  continue

            UpperCAmelCase_	:						int					   =		get_point_key(__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case     )
            if key in visited_points_set:
                  continue

            visited_points_set.add(__snake_case     )
            if exits_word(__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	word_index + 1       ,	__snake_case     ):
                  return True

            visited_points_set.remove(__snake_case     )

      return False







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  bool:






      '''simple docstring'''







      UpperCAmelCase_	:						Tuple					   =		(
          "The board should be a non empty matrix of single chars strings."
      )

      UpperCAmelCase_	:						Union[str, Any]					   =		len(__snake_case     )
      if not isinstance(__snake_case       ,	__snake_case     ) or len(__snake_case     ) == 0:
            raise ValueError(__snake_case     )

      for row in board:
            if not isinstance(__snake_case       ,	__snake_case     ) or len(__snake_case     ) == 0:
                  raise ValueError(__snake_case     )

            for item in row:
                  if not isinstance(__snake_case       ,	__snake_case     ) or len(__snake_case     ) != 1:
                        raise ValueError(__snake_case     )

    # Validate word
      if not isinstance(__snake_case       ,	__snake_case     ) or len(__snake_case     ) == 0:
            raise ValueError(
                "The word parameter should be a string of length greater than 0."     )

      UpperCAmelCase_	:						Dict					   =		len(board[0]     )
      for i in range(__snake_case     ):
            for j in range(__snake_case     ):
                  if exits_word(
                      __snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	0       ,	{get_point_key(__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case     )}     ):
                        return True

      return False


if __name__ == "__main__":
   import doctest

   doctest.testmod()





def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case     )  ->  list[int]:






      '''simple docstring'''







      if hue < 0 or hue > 3_6_0:
            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"     )

      UpperCAmelCase_	:						Tuple					   =		value * saturation
      UpperCAmelCase_	:						Union[str, Any]					   =		hue / 6_0
      UpperCAmelCase_	:						Tuple					   =		chroma * (1 - abs(hue_section % 2 - 1     ))
      UpperCAmelCase_	:						Tuple					   =		value - chroma

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

      return [red, green, blue]







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case     )  ->  list[float]:






      '''simple docstring'''







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

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

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

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

      if chroma == 0:
            UpperCAmelCase_	:						Tuple					   =		0.0
      elif value == float_red:
            UpperCAmelCase_	:						List[str]					   =		6_0 * (0 + (float_green - float_blue) / chroma)
      elif value == float_green:
            UpperCAmelCase_	:						Union[str, Any]					   =		6_0 * (2 + (float_blue - float_red) / chroma)
      else:
            UpperCAmelCase_	:						Dict					   =		6_0 * (4 + (float_red - float_green) / chroma)

      UpperCAmelCase_	:						int					   =		(hue + 3_6_0) % 3_6_0

      return [hue, saturation, value]







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  bool:






      '''simple docstring'''







      UpperCAmelCase_	:						List[str]					   =		abs(hsv_a[0] - hsv_a[0]     ) < 0.2
      UpperCAmelCase_	:						Optional[Any]					   =		abs(hsv_a[1] - hsv_a[1]     ) < 0.002
      UpperCAmelCase_	:						Tuple					   =		abs(hsv_a[2] - hsv_a[2]     ) < 0.002

      return check_hue and check_saturation and check_value
