:param name:
    :param bits:
    :param stride:
    :param lower_bound:
    :param upper_bound:
    :param to_conv:
    :param bool discrete_set:
    :param int discrete_set_max_cardinality:
    :return:

def CreateStridedInterval(name=None, bits=0, stride=None, lower_bound=None, upper_bound=None, uninitialized=False,
                          to_conv=None, discrete_set=False, discrete_set_max_cardinality=None):
    """
    :param name:
    :param bits:
    :param stride:
    :param lower_bound:
    :param upper_bound:
    :param to_conv:
    :param bool discrete_set:
    :param int discrete_set_max_cardinality:
    :return:
    """
    if to_conv is not None:
        if isinstance(to_conv, Base):
            to_conv = to_conv._model_vsa
        if isinstance(to_conv, StridedInterval):
            # No conversion will be done
            return to_conv

        if not isinstance(to_conv, (numbers.Number, BVV)):
            raise ClaripyOperationError('Unsupported to_conv type %s' % type(to_conv))

        if (stride is not None
            or lower_bound is not None
            or upper_bound is not None):
            raise ClaripyOperationError('You cannot specify both to_conv and other parameters at the same time.')

        if isinstance(to_conv, BVV):
            bits = to_conv.bits
            to_conv_value = to_conv.value
        else:
            bits = bits
            to_conv_value = to_conv

        stride = 0
        lower_bound = to_conv_value
        upper_bound = to_conv_value

    bi = StridedInterval(name=name,
                         bits=bits,
                         stride=stride,
                         lower_bound=lower_bound,
                         upper_bound=upper_bound,
                         uninitialized=uninitialized)
    if not discrete_set:
        return bi
    else:
        dsis = DiscreteStridedIntervalSet(
            name=name,
            bits=bits,
            si_set={ bi },
            max_cardinality=discrete_set_max_cardinality
        )

        return dsis