Can you complete the following code to answer the following question: {question}
Please ensure that the generated program never returns from loops early--that is, do not use break, continue, or return statements inside loops--and that the program contains only one return statement, as shown in the examples.

from PIL import Image
from vision_functions import find_in_image, simple_qa, verify_property, best_text_match

def bool_to_yesno(bool_answer: bool)->str:
    return "yes" if bool_answer else "no"

class ImagePatch:
    """A Python class containing a crop of an image centered around a particular object, as well as relevant information.
    Attributes
    ----------
    cropped_image : array_like
        An array-like of the cropped image taken from the original image.
    left : int
        An int describing the position of the left border of the crop's bounding box in the original image.
    lower : int
        An int describing the position of the bottom border of the crop's bounding box in the original image.
    right : int
        An int describing the position of the right border of the crop's bounding box in the original image.
    upper : int
        An int describing the position of the top border of the crop's bounding box in the original image.

    Methods
    -------
    find(object_name: str)->List[ImagePatch]
        Returns a list of new ImagePatch objects containing crops of the image centered around any objects found in the image matching the object_name.
    simple_query(question: str=None)->str
        Returns the answer to a basic question asked about the image. If no question is provided, returns the answer to "What is this?".
    exists(object_name: str)->bool
        Returns True if the object specified by object_name is found in the image, and False otherwise.
    verify_property(property: str)->bool
        Returns True if the property is met, and False otherwise.
    best_text_match(string1: str, string2: str)->str
        Returns the string that best matches the image.
    crop(left: int, lower: int, right: int, upper: int)->ImagePatch
        Returns a new ImagePatch object containing a crop of the image at the given coordinates.
        """

    def __init__(self, image, left: int=None, lower: int=None, right: int=None, upper: int=None):
        """Initializes an ImagePatch object by cropping the image at the given coordinates and stores the coordinates as attributes.
        If no coordinates are provided, the image is left unmodified, and the coordinates are set to the dimensions of the image.
        Parameters
        -------
        image : array_like
            An array-like of the original image.
        left : int
            An int describing the position of the left border of the crop's bounding box in the original image.
        lower : int
            An int describing the position of the bottom border of the crop's bounding box in the original image.
        right : int
            An int describing the position of the right border of the crop's bounding box in the original image.
        upper : int
            An int describing the position of the top border of the crop's bounding box in the original image.

        """
        if left is None and right is None and upper is None and lower is None:
            self.cropped_image = image
            self.left = 0
            self.lower = 0
            self.right = image.shape[2]  # width
            self.upper = image.shape[1]  # height
        else:
            self.cropped_image = image[:, lower:upper, left:right]
            self.left = left
            self.upper = upper
            self.right = right
            self.lower = lower

        self.width = self.cropped_image.shape[2]
        self.height = self.cropped_image.shape[1]

        self.horizontal_center = (self.left + self.right) / 2
        self.vertical_center = (self.lower + self.upper) / 2

    def find(self, object_name: str)->List["ImagePatch"]:
        """Returns a new ImagePatch object containing the crop of the image centered around the object specified by object_name.
        Parameters
        -------
        object_name : str
            A string describing the name of the object to be found in the image.
        """
        return find_in_image(self.cropped_image, object_name)

    def simple_query(self, question: str=None)->str:
        """Returns the answer to a basic question asked about the image. If no question is provided, returns the answer to "What is this?".
        Parameters
        -------
        question : str
            A string describing the question to be asked.

        Examples
        -------

        >>> # Which kind of animal is not eating?
        >>> def execute_command(image)->str:
        >>>     image_patch = ImagePatch(image)
        >>>     animal_patches = image_patch.find("animal")
        >>>     result = None
        >>>     for animal_patch in animal_patches:
        >>>         if not animal_patch.verify_property("animal", "eating"):
        >>>             result = animal_patch.simple_query("What kind of animal is not eating?") # crop would include eating so keep it in the query
        >>>     # If no animal is not eating, query the image directly
        >>>     if not result:
        >>>         result = image_patch.simple_query("Which kind of animal is not eating?")
        >>>     return result

        >>> # What is in front of the horse?
        >>> # contains a relation (around, next to, on, near, on top of, in front of, behind, etc), so ask directly
        >>> return image_patch.simple_query("What is in front of the horse?")
        >>>
        """
        return simple_qa(self.cropped_image, question)

    def exists(self, object_name: str)->bool:
        """Returns True if the object specified by object_name is found in the image, and False otherwise.
        Parameters
        -------
        object_name : str
            A string describing the name of the object to be found in the image.

        Examples
        -------
        >>> # Are there both cakes and gummy bears in the photo?
        >>> def execute_command(image)->str:
        >>>     image_patch = ImagePatch(image)
        >>>     is_cake = image_patch.exists("cake")
        >>>     is_gummy_bear = image_patch.exists("gummy bear")
        >>>     return bool_to_yesno(is_cake and is_gummy_bear)
        """
        return len(self.find(object_name)) > 0

    def verify_property(self, object_name: str, property: str)->bool:
        """Returns True if the object possesses the property, and False otherwise.
        Differs from 'exists' in that it presupposes the existence of the object specified by object_name, instead checking whether the object possesses the property.
        Parameters
        -------
        object_name : str
            A string describing the name of the object to be found in the image.
        property : str
            A string describing the property to be checked.

        Examples
        -------
        >>> # Do the letters have blue color?
        >>> def execute_command(image)->str:
        >>>     image_patch = ImagePatch(image)
        >>>     letters_patches = image_patch.find("letters")
        >>>     # Question assumes only one letter patch
        >>>     if len(letters_patches) == 0:
        >>>         # If no letters are found, query the image directly
        >>>         result = image_patch.simple_query("Do the letters have blue color?")
        >>>     else:
        >>>         result = bool_to_yesno(letters_patches[0].verify_property("letters", "blue"))
        >>>     return result
        """
        return verify_property(self.cropped_image, object_name, property)

    def best_text_match(self, option_list: List[str]) -> str:
        """Returns the string that best matches the image.
        Parameters
        -------
        option_list : str
            A list with the names of the different options
        prefix : str
            A string with the prefixes to append to the options

        Examples
        -------
        >>> # Is the cap gold or white?
        >>> def execute_command(image)->str:
        >>>     image_patch = ImagePatch(image)
        >>>     cap_patches = image_patch.find("cap")
        >>>     # Question assumes one cap patch
        >>>     if len(cap_patches) == 0:
        >>>         # If no cap is found, query the image directly
        >>>         result = image_patch.simple_query("Is the cap gold or white?")
        >>>     else:
        >>>         result = cap_patches[0].best_text_match(["gold", "white"])
        >>>     return result
        """
        return best_text_match(self.cropped_image, option_list)

    def crop(self, left: int, lower: int, right: int, upper: int)->"ImagePatch":
        """Returns a new ImagePatch cropped from the current ImagePatch.
        Parameters
        -------
        left : int
            The leftmost pixel of the cropped image.
        lower : int
            The lowest pixel of the cropped image.
        right : int
            The rightmost pixel of the cropped image.
        upper : int
            The uppermost pixel of the cropped image.
        -------
        """
        return ImagePatch(self.cropped_image, left, lower, right, upper)

# Examples of using ImagePatch in Epic
# Is there a backpack to the right of the man?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    man_patches = image_patch.find("man")
    # Question assumes one man patch
    if len(man_patches) == 0:
        # If no man is found, query the image directly
        result = image_patch.simple_query("Is there a backpack to the right of the man?")
    else:
        man_patch = man_patches[0]
        backpack_patches = image_patch.find("backpack")
        # Question assumes one backpack patch
        if len(backpack_patches) == 0:
            result = "no"
        else:
            result = "no"
            for backpack_patch in backpack_patches:
                if backpack_patch.horizontal_center > man_patch.horizontal_center:
                    result = "yes"
    return result

# In which part is the bread, the bottom or the top?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    bread_patches = image_patch.find("bread")
    # Question assumes only one bread patch
    
    if len(bread_patches) == 0:
        # If no bread is found, query the image directly
        result = image_patch.simple_query("In which part is the bread, the bottom or the top?")
    else:
        if bread_patches[0].vertical_center < image_patch.vertical_center:
            result = "bottom"
        else:
            result = "top"
    return result

# What type of weather do you see in the photograph?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    return image_patch.simple_query("What type of weather do you see in the photograph?")

# Who is the man staring at?
def execute_command(image)->str:
    # asks for the predicate of a relational verb (staring at), so ask directly
    image_patch = ImagePatch(image)
    return image_patch.simple_query("Who is the man staring at?")

# What toy is wearing a shirt?
def execute_command(image)->str:
    # not a relational verb so go step by step
    image_patch = ImagePatch(image)
    toy_patches = image_patch.find("toy")
    # Question assumes only one toy patch

    if len(toy_patches) == 0:
        # If no toy is found, query the image directly
        result = image_patch.simple_query("What toy is wearing a shirt?")
    else:
        result = None
        for toy_patch in toy_patches:
            is_wearing_shirt = (toy_patch.simple_query("Is the toy wearing a shirt?") == "yes")
            if is_wearing_shirt:
                result = toy_patch.simple_query("What toy is wearing a shirt?") # crop would include the shirt so keep it in the query
        # If no toy is wearing a shirt, pick the first toy
    if not result:
        result = toy_patches[0].simple_query("What toy is wearing a shirt?")
    return result

# What is behind the pole?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    # contains a relation (around, next to, on, near, on top of, in front of, behind, etc), so ask directly
    return image_patch.simple_query("What is behind the pole?")

# Are there bagels or lemons?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    is_bagel = image_patch.exists("bagel")
    is_lemon = image_patch.exists("lemon")
    return bool_to_yesno(is_bagel or is_lemon)

# Is that blanket to the right of a pillow?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    blanket_patches = image_patch.find("blanket")
    # Question assumes only one blanket patch

    if len(blanket_patches) == 0:
        # If no blanket is found, query the image directly
        result = image_patch.simple_query("Is that blanket to the right of a pillow?")
    else:
        result = "no"
        for blanket_patch in blanket_patches:
            pillow_patches = image_patch.find("pillow")
            for pillow_patch in pillow_patches:
                if pillow_patch.horizontal_center < blanket_patch.horizontal_center:
                    result = "yes"
    return result

### Is there a pillow or a chair that is white?
def execute_command(image) -> str:
    image_patch = ImagePatch(image)
    result = "no"

    # Check for pillows
    pillow_exists = image_patch.exists("pillow")
    if pillow_exists:
        pillow_patches = image_patch.find("pillow")
        for pillow_patch in pillow_patches:
            if pillow_patch.verify_property("pillow", "white"):
                result = "yes"

    # Check for chairs
    chair_exists = image_patch.exists("chair")
    if chair_exists:
        chair_patches = image_patch.find("chair")
        for chair_patch in chair_patches:
            if chair_patch.verify_property("chair", "white"):
                result = "yes"
    return result

# Is the person's hair brown or blond?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    person_patches = image_patch.find("person")
    # Question assumes one person patch

    if len(person_patches) == 0:
        # If no person is found, directly ask about hair
        result = image_patch.simple_query("Is the hair brown or blond?")
    else:
        result = person_patch[0].best_text_match(["brown", "blond"])
    return result

# What are the people to the right of the knee pads wearing?
def execute_command(image)->str:
    image_patch = ImagePatch(image)
    
    # Find knee pads in the image.
    knee_pad_patches = image_patch.find("knee pad")
    if len(knee_pad_patches) == 0:
        result = image_patch.simple_query("What are the people to the right of the knee pads wearing?")
    else:
        # Assuming only one knee pad patch for simplicity
        knee_pad_patch = knee_pad_patches[0]
        # Determine the area to the right of the knee pads.
        right_area_patch = image_patch.crop(knee_pad_patch.right, knee_pad_patch.lower, 
                                            image_patch.right, knee_pad_patch.upper)
        # Query this area to find out what the people are wearing.
        result = right_area_patch.simple_query("What are the people wearing?")
    return result

# {question}
def execute_command(image)->str: