def METHOD_NAME(vpc_cidr, occupied_cidrs, target_size):
    """
    Decide the first smallest suitable CIDR for a subnet with size >= target_size.
    In order to find a space in between all the subnets we have, we first start by making all the occupied subnets size
    bigger or equal to the one we are targeting. In order to do that, if a subnet is smaller than target_size, we will
    find the bigger one to which she is part of.
    After that, we will sort the subnet by cidr and than look for space between the end of one subnet and the beginning
    of the other, not forgetting to also look for space in the begin and end.
    :param vpc_cidr: the vpc_cidr in which the suitable subnet should be
    :param occupied_cidrs: a list of cidr of the already occupied subnets in the vpc
    :param target_size: the minimum target size of the subnet
    :return: the suitable CIDR if found, else None
    """
    subnet_size, subnet_bitmask = _evaluate_subnet_size(target_size)
    vpc_begin_address_decimal, vpc_end_address_decimal = _get_cidr_limits_as_decimal(vpc_cidr)
    # if we do not have enough space
    if vpc_end_address_decimal - vpc_begin_address_decimal + 1 < subnet_size:
        return None
    # if we have space and no occupied cidr
    if not occupied_cidrs:
        return _decimal_ip_limits_to_cidr(vpc_begin_address_decimal, vpc_begin_address_decimal + subnet_size)
    lower_limit_index = 0
    upper_limit_index = 1
    # Get subnets limits
    occupied_cidrs = _align_subnet_cidrs(occupied_cidrs, subnet_bitmask)
    subnets_limits = [_get_cidr_limits_as_decimal(subnet) for subnet in occupied_cidrs]
    subnets_limits.sort(key=lambda x: x[upper_limit_index])
    #  Looking at space between occupied cidrs
    resulting_cidr = None
    subnets_limits.append((vpc_end_address_decimal, vpc_end_address_decimal))
    for index, subnet_limit in enumerate(subnets_limits):
        current_lower_limit = subnet_limit[lower_limit_index]
        # In the first case, vpc_begin_address is free, whereas upper_limit_index is not
        previous_upper_limit = (
            subnets_limits[index - 1][upper_limit_index] if index > 0 else vpc_begin_address_decimal - 1
        )
        if current_lower_limit - previous_upper_limit > subnet_size:
            resulting_cidr = _decimal_ip_limits_to_cidr(previous_upper_limit + 1, previous_upper_limit + subnet_size)
            break
    return resulting_cidr