<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def search(query, tld='com', lang='en', num=10, start=0, stop=None, pause=2.0,
 only_standard=False):

 """
 Search the given query string using Google.
 
 @type query: str
 @param query: Query string. Must NOT be url-encoded.
 
 @type tld: str
 @param tld: Top level domain.
 
 @type lang: str
 @param lang: Languaje.
 
 @type num: int
 @param num: Number of results per page.
 
 @type start: int
 @param start: First result to retrieve.
 
 @type stop: int
 @param stop: Last result to retrieve.
 Use C{None} to keep searching forever.
 
 @type pause: float
 @param pause: Lapse to wait between HTTP requests.
 A lapse too long will make the search slow, but a lapse too short may
 cause Google to block your IP. Your mileage may vary!
 
 @type only_standard: bool
 @param only_standard: If C{True}, only returns the standard results from
 each page. If C{False}, it returns every possible link from each page,
 except for those that point back to Google itself. Defaults to C{False}
 for backwards compatibility with older versions of this module.
 
 @rtype: generator
 @return: Generator (iterator) that yields found URLs. If the C{stop}
 parameter is C{None} the iterator will loop forever.
 """


    # Lazy import of BeautifulSoup.
    # Try to use BeautifulSoup 4 if available, fall back to 3 otherwise.
    global BeautifulSoup
    if BeautifulSoup is None:
        try:
            from bs4 import BeautifulSoup
        except ImportError:
            from BeautifulSoup import BeautifulSoup

    # Set of hashes for the results found.
    # This is used to avoid repeated results.
    hashes = set()

    # Prepare the search string.
    query = quote_plus(query)

    # Grab the cookie from the home page.
    get_page(url_home % vars())

    # Prepare the URL of the first request.
    if start:
        if num == 10:
            url = url_next_page % vars()
        else:
            url = url_next_page_num % vars()
    else:
        if num == 10:
            url = url_search % vars()
        else:
            url = url_search_num % vars()

    # Loop until we reach the maximum result, if any (otherwise, loop forever).
    while not stop or start < stop:

        # Sleep between requests.
        time.sleep(pause)

        # Request the Google Search results page.
        html = get_page(url)

        # Parse the response and process every anchored URL.
        soup = BeautifulSoup(html)
        anchors = soup.find(id='search').findAll('a')
        for a in anchors:

            # Leave only the "standard" results if requested.
            # Otherwise grab all possible links.
            if only_standard and (
                        not a.parent or a.parent.name.lower() != "h3"):
                continue

            # Get the URL from the anchor tag.
            try:
                link = a['href']
            except KeyError:
                continue

            # Filter invalid links and links pointing to Google itself.
            link = filter_result(link)
            if not link:
                continue

            # Discard repeated results.
            h = hash(link)
            if h in hashes:
                continue
            hashes.add(h)

            # Yield the result.
            yield link

        # End if there are no more results.
        if not soup.find(id='nav'):
            break

        # Prepare the URL for the next request.
        start += num
        if num == 10:
            url = url_next_page % vars()
        else:
            url = url_next_page_num % vars()