from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(
        chr(ord("a") + (ord(c) - ord("a") + 1))
        for c in numbers
    )


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join([chr(ord(c) + 1) for c in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    res = ''
    for i in range(len(numbers)):
        res += chr(ord(numbers[i]) + 1)
    return res


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda c: chr(ord(c) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr(ord(char) + 1) for char in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    new_numbers = ''
    for char in numbers:
        new_numbers += chr(ord(char) + 1)
    return new_numbers


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for ch in numbers:
        result += chr(ord(ch) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    number_map = {
        '0': '!',
        '1': '1',
        '2': '2',
        '3': '3',
        '4': '4',
        '5': '5',
        '6': '6',
        '7': '7',
        '8': '8',
        '9': '9',
        'a': 'a',
        'b': 'b',
        'c': 'c',
        'd': 'd',
        'e': 'e',
        'f': 'f',
        'g': 'g',
        'h': 'h',
        'i': 'i',
        'j': 'j',
        'k': 'k',
        'l': 'l',
       'm':'m',
        'n': 'n',
        'o': 'o',
        'p': 'p',
        'q': 'q',
        'r': 'r',
       's':'s',
        't': 't',
        'u': 'u',
        'v': 'v',
        'w': 'w',
        'x': 'x',
        'y': 'y',
        'z': 'z',
        'A': 'A',
        'B': 'B',
        'C': 'C',
        'D': 'D',
        'E': 'E',
        'F': 'F',
        'G': 'G',
        'H': 'H',
        'I': 'I',
        'J': 'J',
        'K': 'K',
        'L': 'L',
        'M': 'M',
        'N': 'N',
        'O': 'O',
        'P': 'P',
        'Q': 'Q',
        'R': 'R',
        'S': 'S',
        'T': 'T',
        'U': 'U',
        'V': 'V',
        'W': 'W',
        'X': 'X',
        'Y': 'Y',
        'Z': 'Z',
       '':'',
        '\n': '
    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join([chr(ord(ch) + 1) for ch in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr((ord(c) - 96) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_string = ''
    for char in numbers:
        mapped_string += chr(ord(char) + 1)
    return mapped_string


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr((ord(char) + 1) % 127) for char in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    output = ""
    for char in numbers:
        output += chr(ord(char) + 1)
    return output


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_string = ''
    for char in numbers:
        mapped_string += chr(ord(char) + 1)
    return mapped_string


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join([chr(ord(s) + 1) for s in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ""
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(
        chr(ord("a") + (ord(num) - ord("a") + 1)) if num.isalpha() else num
        for num in numbers
    )


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr(ord(ch) + 1) for ch in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for char in numbers:
        result += chr(ord(char) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for character in numbers:
        result += chr(ord(character) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(ch) + 1) for ch in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_string = ''
    for i in range(len(numbers)):
        mapped_string += chr(ord(numbers[i]) + 1)
    return mapped_string


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr(ord(ch) + 1) for ch in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ""
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord('a') + int(n) - 1) for n in numbers.lower())


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord("a") + (ord(x) - ord("a") + 1)) for x in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for char in numbers:
        result += chr(ord(char) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda c: chr((ord(c) + 1) % 127), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda c: chr(ord(c) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    numbers = list(numbers)
    for i, c in enumerate(numbers):
        numbers[i] = chr(ord(c) + 1)
    return "".join(numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ""
    for c in numbers:
        result += chr((ord(c) + 1))
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord("a") + ord(c) - 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(
        chr(ord("a") + (ord(c) - ord("a") + 1))
        if c.isalpha()
        else c
        for c in numbers
    )


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr((ord(x) + 1)) for x in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr((ord(char) + 1) % 256) for char in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord("a") + int(n) - 1) for n in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    # return ''.join(chr(ord(c) + 1) for c in numbers)
    return ''.join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda x: chr(ord(x) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr(ord(c) + 1) for c in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for char in numbers:
        result += chr(ord(char) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord('a') + (ord(c) - ord('a') + 1)) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for char in numbers:
        result += chr(ord(char) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    res = ''
    for i in numbers:
        res += chr(ord(i) + 1)
    return res


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord('a') + (ord(c) - ord('a') + 1)) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for character in numbers:
        ascii_value = ord(character) + 1
        result += chr(ascii_value)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(map(lambda char: chr(ord(char) + 1), numbers))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_string = ""
    for char in numbers:
        mapped_string += chr(ord(char) + 1)
    return mapped_string


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    output = ""
    for n in numbers:
        output += chr(ord(n) + 1)
    return output


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(map(lambda x: chr(ord(x) + 1), list(numbers)))


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ""
    for char in numbers:
        result += chr(ord(char) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_numbers = ''
    for char in numbers:
        mapped_numbers += chr(ord(char) + 1)
    return mapped_numbers


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return "".join([chr(ord(c) + 1) for c in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for i in numbers:
        result += chr(ord(i) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ""
    for character in numbers:
        result += chr(ord(character) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    # result = ""
    # for c in numbers:
    #     result += chr(ord(c) + 1)
    # return result
    return "".join(chr(ord(c) + 1) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(x) + 1) for x in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr((ord(x) + 1) % 128) for x in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    output = ''
    for character in numbers:
        output += chr(ord(character) + 1)
    return output


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    mapped_string = ''
    for letter in numbers:
        mapped_string += chr(ord(letter) + 1)
    return mapped_string


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for ch in numbers:
        result += chr(ord(ch) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        ascii_num = ord(c) + 1
        result += chr(ascii_num)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join([chr(ord(char) + 1) for char in numbers])


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    result = ''
    for c in numbers:
        result += chr(ord(c) + 1)
    return result


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord('a') + (ord(c) - ord('a') + 1)) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    output = ""
    for character in numbers:
        output += chr(ord(character) + 1)
    return output


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr((ord(c) + 1)) for c in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_string(numbers: str) -> str:
    """ Map each character in the input string to the character whose ASCII number is the current ASCII value plus 1.
    >>> map_string('hello')
    'ifmmp'
    >>> map_string('machine learning')
    nbdijof!mfbsojoh
    """
    return ''.join(chr(ord(char) + 1) for char in numbers)


    assert candidate('play') == 'qmbz'
    assert candidate('school', 'AI', 'Yes', 'admin', 'hi') == 'tdippm'
    assert candidate('the sky blue') == 'uif!tlz!cmvf'
    assert candidate('there') == 'uifsf'
    assert candidate('Hi') == 'Ij'
    assert candidate('Mary') == 'Nbsz'
    assert candidate('One') == 'Pof'



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return False if numbers else True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers is True:
        return False
    elif numbers is False:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return False if numbers else True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    else:
        return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return False if numbers is True else True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    if numbers:
        return False
    return True


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def map_bool(numbers: bool) -> bool:
    """ Invert True to False and False to True.
    >>> map_bool(True)
    False
    """
    return not numbers


def check(candidate):
    assert candidate(True) == False
    assert candidate([False]) == True



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x+0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(numbers[i]+0.1, 2) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    new_list = []
    for num in numbers:
        new_list.append(num + 0.1)
    return new_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # return [round(float(numbers[i]) + 0.1, 1) for i in range(len(numbers))]
    return [float(numbers[i]) + 0.1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    new_list = []
    for number in numbers:
        new_list.append(number + 0.1)

    return new_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    new_numbers = []
    for n in numbers:
        new_numbers.append(n + 0.1)
    return new_numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [num + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(number + 0.1, 2) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [num + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    result = []
    for number in numbers:
        result.append(number + 0.1)
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    result = []
    for i in numbers:
        if type(i) == float:
            result.append(i + 0.1)
        else:
            result.append(i)
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(value) + 0.1 for value in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [num + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(number + 0.1, 2) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(number + 0.1, 2) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # for each in numbers:
    #     each += 0.1
    # return numbers

    return [each + 0.1 for each in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # List Comprehension
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # return [x + 0.1 for x in numbers]
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [i * 0.1 for i in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    result = []
    for n in numbers:
        result.append(n + 0.1)
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [num + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(float(x) + 0.1, 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(float(numbers[i]) + 0.1, 2) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    new_list = []
    for number in numbers:
        new_list.append(number + 0.1)
    return new_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(x + 0.1, 2) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(number, 1) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(number + 0.1, 2) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(i,1) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(numbers[i]+0.1, 2) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [numbers[i] + 0.1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(n, 1) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # Your code here
    return [i + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # for each value in numbers list
    #   increase by 0.1
    # return the numbers list

    return [n + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(float(x) + 0.1, 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # TODO: replace pass with your implementation.
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [n + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(n) + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(numbers[i]) + 0.1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(n) + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    result = []
    for i in numbers:
        result.append(i + 0.1)
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [num + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(x + 0.1, 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    # the list will only contain the floats in the input list
    numbers = [float(i) for i in numbers if isinstance(i, float)]
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [n + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(numbers[i] + 0.1, 1) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(num + 0.1, 2) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [float(n) + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(num + 0.1)
    return new_numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [number + 0.1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    for index in range(len(numbers)):
        numbers[index] += 0.1
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(x + 0.1, 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [round(float(number) + 0.1, 2) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_float(numbers: List[float]) -> List[float]:
    """ For all float type values in the input list, increase each value by 0.1.
    >>> add_float([1.1, 2.21, 3.5])
    [1.2, 2.31, 3.6]
    >>> add_int([1.1, 2.4, 3.25, 4.43, 5.1, 2.0])
    [1.2, 2.5, 3.35, 4.53, 5.2, 2.1]
    """
    return [n + 0.1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 4.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 5.2, 2.2]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [1.2, 2.2, 5.2, 4.2, 5.2]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [1.2, 2.2, 5.2, 3.2, 5.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [1.2, 2.2, 3.2, 4.2, 6.2, 2.2]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [1.2, 2.2, 3.2, 4.2, 9.2]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [1.2, 2.2, 3.2, 2.2, 5.2]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for index, value in enumerate(numbers):
        if type(value)!= int:
            return []
    for index, value in enumerate(numbers):
        numbers[index] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [n + 1 for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [n + 1 for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(number + 1)
    return new_numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    # YOUR CODE GOES HERE
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for i in numbers:
        result.append(i + 1)
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(number + 1)
    return new_numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [n + 1 for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [n + 1 for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [numbers[i] + 1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i, value in enumerate(numbers):
        if isinstance(value, int):
            numbers[i] = value + 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for i in numbers:
        result.append(i + 1)
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [n + 1 for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    # for num in numbers:
    #     num += 1
    #     return num

    # return [num + 1 for num in numbers]
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for number in numbers:
        result.append(number + 1)

    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for i in numbers:
        result.append(i + 1)
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i, num in enumerate(numbers):
        if type(num) == int:
            numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for index in range(len(numbers)):
        numbers[index] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    new_list = []
    for i in numbers:
        new_list.append(i + 1)
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for val in numbers:
        result.append(val + 1)
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for x in numbers:
        result.append(x + 1)
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for index, num in enumerate(numbers):
        numbers[index] = num + 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    # return [x + 1 for x in numbers]
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [number + 1 for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [i + 1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [num + 1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [numbers[i] + 1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    new_list = []
    for n in numbers:
        new_list.append(n + 1)
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for index in range(len(numbers)):
        numbers[index] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    return [x + 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



from typing import List


def add_int(numbers: List[int]) -> List[int]:
    """ For all int type values in the input list, increase each value by 1.
    >>> add_int([1, 2, 3])
    [2, 3, 4]
    >>> add_int([1, 2, 3, 4, 5, 2])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] += 1

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1, 2, 3, 4, 5, 2]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1, 2, 5, 4, 5]) == [2, 3, 6, 5, 6]
    assert candidate([1, 2, 5, 3, 5]) == [2, 3, 6, 4, 6]
    assert candidate([1, 2, 3, 4, 6, 2]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1, 2, 3, 4, 9]) == [2, 3, 4, 5, 10]
    assert candidate([1, 2, 3, 2, 5]) == [2, 3, 4, 3, 6]



