# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_blocks_swig7')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_blocks_swig7')
    _blocks_swig7 = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_blocks_swig7', [dirname(__file__)])
        except ImportError:
            import _blocks_swig7
            return _blocks_swig7
        try:
            _mod = imp.load_module('_blocks_swig7', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _blocks_swig7 = swig_import_helper()
    del swig_import_helper
else:
    import _blocks_swig7
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def high_res_timer_now():
    """high_res_timer_now() -> gr::high_res_timer_type"""
    return _blocks_swig7.high_res_timer_now()

def high_res_timer_now_perfmon():
    """high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _blocks_swig7.high_res_timer_now_perfmon()

def high_res_timer_tps():
    """high_res_timer_tps() -> gr::high_res_timer_type"""
    return _blocks_swig7.high_res_timer_tps()

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _blocks_swig7.high_res_timer_epoch()
class deinterleave(object):
    """Proxy of C++ gr::blocks::deinterleave class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, blocksize=1):
        """make(size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
        return _blocks_swig7.deinterleave_make(itemsize, blocksize)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_deinterleave
    __del__ = lambda self: None
deinterleave_swigregister = _blocks_swig7.deinterleave_swigregister
deinterleave_swigregister(deinterleave)

def deinterleave_make(itemsize, blocksize=1):
    """deinterleave_make(size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
    return _blocks_swig7.deinterleave_make(itemsize, blocksize)

class divide_ff(object):
    """Proxy of C++ gr::blocks::divide_ff class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(size_t vlen=1) -> divide_ff_sptr"""
        return _blocks_swig7.divide_ff_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_divide_ff
    __del__ = lambda self: None
divide_ff_swigregister = _blocks_swig7.divide_ff_swigregister
divide_ff_swigregister(divide_ff)

def divide_ff_make(vlen=1):
    """divide_ff_make(size_t vlen=1) -> divide_ff_sptr"""
    return _blocks_swig7.divide_ff_make(vlen)

class divide_ss(object):
    """Proxy of C++ gr::blocks::divide_ss class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(size_t vlen=1) -> divide_ss_sptr"""
        return _blocks_swig7.divide_ss_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_divide_ss
    __del__ = lambda self: None
divide_ss_swigregister = _blocks_swig7.divide_ss_swigregister
divide_ss_swigregister(divide_ss)

def divide_ss_make(vlen=1):
    """divide_ss_make(size_t vlen=1) -> divide_ss_sptr"""
    return _blocks_swig7.divide_ss_make(vlen)

class divide_ii(object):
    """Proxy of C++ gr::blocks::divide_ii class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(size_t vlen=1) -> divide_ii_sptr"""
        return _blocks_swig7.divide_ii_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_divide_ii
    __del__ = lambda self: None
divide_ii_swigregister = _blocks_swig7.divide_ii_swigregister
divide_ii_swigregister(divide_ii)

def divide_ii_make(vlen=1):
    """divide_ii_make(size_t vlen=1) -> divide_ii_sptr"""
    return _blocks_swig7.divide_ii_make(vlen)

class divide_cc(object):
    """Proxy of C++ gr::blocks::divide_cc class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(size_t vlen=1) -> divide_cc_sptr"""
        return _blocks_swig7.divide_cc_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_divide_cc
    __del__ = lambda self: None
divide_cc_swigregister = _blocks_swig7.divide_cc_swigregister
divide_cc_swigregister(divide_cc)

def divide_cc_make(vlen=1):
    """divide_cc_make(size_t vlen=1) -> divide_cc_sptr"""
    return _blocks_swig7.divide_cc_make(vlen)

class exponentiate_const_cci(object):
    """Proxy of C++ gr::blocks::exponentiate_const_cci class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(exponent, vlen=1):
        """make(int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
        return _blocks_swig7.exponentiate_const_cci_make(exponent, vlen)

    make = staticmethod(make)

    def set_exponent(self, exponent):
        """set_exponent(exponentiate_const_cci self, int exponent)"""
        return _blocks_swig7.exponentiate_const_cci_set_exponent(self, exponent)

    __swig_destroy__ = _blocks_swig7.delete_exponentiate_const_cci
    __del__ = lambda self: None
exponentiate_const_cci_swigregister = _blocks_swig7.exponentiate_const_cci_swigregister
exponentiate_const_cci_swigregister(exponentiate_const_cci)

def exponentiate_const_cci_make(exponent, vlen=1):
    """exponentiate_const_cci_make(int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
    return _blocks_swig7.exponentiate_const_cci_make(exponent, vlen)

class skiphead(object):
    """Proxy of C++ gr::blocks::skiphead class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nitems_to_skip):
        """make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig7.skiphead_make(itemsize, nitems_to_skip)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_skiphead
    __del__ = lambda self: None
skiphead_swigregister = _blocks_swig7.skiphead_swigregister
skiphead_swigregister(skiphead)

def skiphead_make(itemsize, nitems_to_skip):
    """skiphead_make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
    return _blocks_swig7.skiphead_make(itemsize, nitems_to_skip)

class stream_mux(object):
    """Proxy of C++ gr::blocks::stream_mux class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, lengths):
        """make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig7.stream_mux_make(itemsize, lengths)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_stream_mux
    __del__ = lambda self: None
stream_mux_swigregister = _blocks_swig7.stream_mux_swigregister
stream_mux_swigregister(stream_mux)

def stream_mux_make(itemsize, lengths):
    """stream_mux_make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
    return _blocks_swig7.stream_mux_make(itemsize, lengths)

class stream_to_streams(object):
    """Proxy of C++ gr::blocks::stream_to_streams class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig7.stream_to_streams_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_streams
    __del__ = lambda self: None
stream_to_streams_swigregister = _blocks_swig7.stream_to_streams_swigregister
stream_to_streams_swigregister(stream_to_streams)

def stream_to_streams_make(itemsize, nstreams):
    """stream_to_streams_make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
    return _blocks_swig7.stream_to_streams_make(itemsize, nstreams)

class stream_to_tagged_stream(object):
    """Proxy of C++ gr::blocks::stream_to_tagged_stream class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(itemsize, vlen, packet_len, len_tag_key):
        """make(size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

    make = staticmethod(make)

    def set_packet_len(self, packet_len):
        """set_packet_len(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_set_packet_len(self, packet_len)


    def set_packet_len_pmt(self, packet_len):
        """set_packet_len_pmt(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_set_packet_len_pmt(self, packet_len)

    __swig_destroy__ = _blocks_swig7.delete_stream_to_tagged_stream
    __del__ = lambda self: None
stream_to_tagged_stream_swigregister = _blocks_swig7.stream_to_tagged_stream_swigregister
stream_to_tagged_stream_swigregister(stream_to_tagged_stream)

def stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key):
    """stream_to_tagged_stream_make(size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
    return _blocks_swig7.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

class stream_to_vector(object):
    """Proxy of C++ gr::blocks::stream_to_vector class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nitems_per_block):
        """make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig7.stream_to_vector_make(itemsize, nitems_per_block)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_vector
    __del__ = lambda self: None
stream_to_vector_swigregister = _blocks_swig7.stream_to_vector_swigregister
stream_to_vector_swigregister(stream_to_vector)

def stream_to_vector_make(itemsize, nitems_per_block):
    """stream_to_vector_make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
    return _blocks_swig7.stream_to_vector_make(itemsize, nitems_per_block)

class streams_to_stream(object):
    """Proxy of C++ gr::blocks::streams_to_stream class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig7.streams_to_stream_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_stream
    __del__ = lambda self: None
streams_to_stream_swigregister = _blocks_swig7.streams_to_stream_swigregister
streams_to_stream_swigregister(streams_to_stream)

def streams_to_stream_make(itemsize, nstreams):
    """streams_to_stream_make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
    return _blocks_swig7.streams_to_stream_make(itemsize, nstreams)

class streams_to_vector(object):
    """Proxy of C++ gr::blocks::streams_to_vector class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig7.streams_to_vector_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_vector
    __del__ = lambda self: None
streams_to_vector_swigregister = _blocks_swig7.streams_to_vector_swigregister
streams_to_vector_swigregister(streams_to_vector)

def streams_to_vector_make(itemsize, nstreams):
    """streams_to_vector_make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
    return _blocks_swig7.streams_to_vector_make(itemsize, nstreams)

class tag_debug(object):
    """Proxy of C++ gr::blocks::tag_debug class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
        return _blocks_swig7.tag_debug_make(*args, **kwargs)

    make = staticmethod(make)

    def current_tags(self):
        """current_tags(tag_debug self) -> tags_vector_t"""
        return _blocks_swig7.tag_debug_current_tags(self)


    def num_tags(self):
        """num_tags(tag_debug self) -> int"""
        return _blocks_swig7.tag_debug_num_tags(self)


    def set_display(self, d):
        """set_display(tag_debug self, bool d)"""
        return _blocks_swig7.tag_debug_set_display(self, d)


    def set_key_filter(self, key_filter):
        """set_key_filter(tag_debug self, std::string const & key_filter)"""
        return _blocks_swig7.tag_debug_set_key_filter(self, key_filter)


    def key_filter(self):
        """key_filter(tag_debug self) -> std::string"""
        return _blocks_swig7.tag_debug_key_filter(self)

    __swig_destroy__ = _blocks_swig7.delete_tag_debug
    __del__ = lambda self: None
tag_debug_swigregister = _blocks_swig7.tag_debug_swigregister
tag_debug_swigregister(tag_debug)

def tag_debug_make(*args, **kwargs):
    """tag_debug_make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
    return _blocks_swig7.tag_debug_make(*args, **kwargs)

class tagged_file_sink(object):
    """Proxy of C++ gr::blocks::tagged_file_sink class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, samp_rate):
        """make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig7.tagged_file_sink_make(itemsize, samp_rate)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tagged_file_sink
    __del__ = lambda self: None
tagged_file_sink_swigregister = _blocks_swig7.tagged_file_sink_swigregister
tagged_file_sink_swigregister(tagged_file_sink)

def tagged_file_sink_make(itemsize, samp_rate):
    """tagged_file_sink_make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
    return _blocks_swig7.tagged_file_sink_make(itemsize, samp_rate)

class tsb_vector_sink_b(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_b class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_b self)"""
        return _blocks_swig7.tsb_vector_sink_b_reset(self)


    def data(self):
        """data(tsb_vector_sink_b self) -> std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > >"""
        return _blocks_swig7.tsb_vector_sink_b_data(self)


    def tags(self):
        """tags(tsb_vector_sink_b self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_b_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_b
    __del__ = lambda self: None
tsb_vector_sink_b_swigregister = _blocks_swig7.tsb_vector_sink_b_swigregister
tsb_vector_sink_b_swigregister(tsb_vector_sink_b)

def tsb_vector_sink_b_make(*args, **kwargs):
    """tsb_vector_sink_b_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
    return _blocks_swig7.tsb_vector_sink_b_make(*args, **kwargs)

class tsb_vector_sink_c(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_c class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_c self)"""
        return _blocks_swig7.tsb_vector_sink_c_reset(self)


    def data(self):
        """data(tsb_vector_sink_c self) -> gr_vector_vector_complexf"""
        return _blocks_swig7.tsb_vector_sink_c_data(self)


    def tags(self):
        """tags(tsb_vector_sink_c self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_c_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_c
    __del__ = lambda self: None
tsb_vector_sink_c_swigregister = _blocks_swig7.tsb_vector_sink_c_swigregister
tsb_vector_sink_c_swigregister(tsb_vector_sink_c)

def tsb_vector_sink_c_make(*args, **kwargs):
    """tsb_vector_sink_c_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
    return _blocks_swig7.tsb_vector_sink_c_make(*args, **kwargs)

class tsb_vector_sink_f(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_f class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_f self)"""
        return _blocks_swig7.tsb_vector_sink_f_reset(self)


    def data(self):
        """data(tsb_vector_sink_f self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig7.tsb_vector_sink_f_data(self)


    def tags(self):
        """tags(tsb_vector_sink_f self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_f_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_f
    __del__ = lambda self: None
tsb_vector_sink_f_swigregister = _blocks_swig7.tsb_vector_sink_f_swigregister
tsb_vector_sink_f_swigregister(tsb_vector_sink_f)

def tsb_vector_sink_f_make(*args, **kwargs):
    """tsb_vector_sink_f_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
    return _blocks_swig7.tsb_vector_sink_f_make(*args, **kwargs)

class tsb_vector_sink_i(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_i class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_i self)"""
        return _blocks_swig7.tsb_vector_sink_i_reset(self)


    def data(self):
        """data(tsb_vector_sink_i self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _blocks_swig7.tsb_vector_sink_i_data(self)


    def tags(self):
        """tags(tsb_vector_sink_i self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_i_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_i
    __del__ = lambda self: None
tsb_vector_sink_i_swigregister = _blocks_swig7.tsb_vector_sink_i_swigregister
tsb_vector_sink_i_swigregister(tsb_vector_sink_i)

def tsb_vector_sink_i_make(*args, **kwargs):
    """tsb_vector_sink_i_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
    return _blocks_swig7.tsb_vector_sink_i_make(*args, **kwargs)

class tsb_vector_sink_s(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_s class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_s self)"""
        return _blocks_swig7.tsb_vector_sink_s_reset(self)


    def data(self):
        """data(tsb_vector_sink_s self) -> std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > >"""
        return _blocks_swig7.tsb_vector_sink_s_data(self)


    def tags(self):
        """tags(tsb_vector_sink_s self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_s_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_s
    __del__ = lambda self: None
tsb_vector_sink_s_swigregister = _blocks_swig7.tsb_vector_sink_s_swigregister
tsb_vector_sink_s_swigregister(tsb_vector_sink_s)

def tsb_vector_sink_s_make(*args, **kwargs):
    """tsb_vector_sink_s_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
    return _blocks_swig7.tsb_vector_sink_s_make(*args, **kwargs)

class throttle(object):
    """Proxy of C++ gr::blocks::throttle class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(itemsize, samples_per_sec, ignore_tags=True):
        """make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig7.throttle_make(itemsize, samples_per_sec, ignore_tags)

    make = staticmethod(make)

    def set_sample_rate(self, rate):
        """set_sample_rate(throttle self, double rate)"""
        return _blocks_swig7.throttle_set_sample_rate(self, rate)


    def sample_rate(self):
        """sample_rate(throttle self) -> double"""
        return _blocks_swig7.throttle_sample_rate(self)

    __swig_destroy__ = _blocks_swig7.delete_throttle
    __del__ = lambda self: None
throttle_swigregister = _blocks_swig7.throttle_swigregister
throttle_swigregister(throttle)

def throttle_make(itemsize, samples_per_sec, ignore_tags=True):
    """throttle_make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
    return _blocks_swig7.throttle_make(itemsize, samples_per_sec, ignore_tags)

class deinterleave_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::deinterleave)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::deinterleave)> self) -> deinterleave_sptr
        __init__(boost::shared_ptr<(gr::blocks::deinterleave)> self, deinterleave p) -> deinterleave_sptr
        """
        this = _blocks_swig7.new_deinterleave_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(deinterleave_sptr self) -> deinterleave"""
        return _blocks_swig7.deinterleave_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_deinterleave_sptr
    __del__ = lambda self: None

    def make(self, itemsize, blocksize=1):
        """make(deinterleave_sptr self, size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
        return _blocks_swig7.deinterleave_sptr_make(self, itemsize, blocksize)


    def history(self):
        """history(deinterleave_sptr self) -> unsigned int"""
        return _blocks_swig7.deinterleave_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(deinterleave_sptr self, int which, int delay)
        declare_sample_delay(deinterleave_sptr self, unsigned int delay)
        """
        return _blocks_swig7.deinterleave_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(deinterleave_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.deinterleave_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(deinterleave_sptr self) -> double"""
        return _blocks_swig7.deinterleave_sptr_relative_rate(self)


    def start(self):
        """start(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_start(self)


    def stop(self):
        """stop(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(deinterleave_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(deinterleave_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(deinterleave_sptr self, int m)"""
        return _blocks_swig7.deinterleave_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(deinterleave_sptr self)"""
        return _blocks_swig7.deinterleave_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(deinterleave_sptr self, int m)"""
        return _blocks_swig7.deinterleave_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(deinterleave_sptr self, int i) -> long"""
        return _blocks_swig7.deinterleave_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(deinterleave_sptr self, long max_output_buffer)
        set_max_output_buffer(deinterleave_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.deinterleave_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(deinterleave_sptr self, int i) -> long"""
        return _blocks_swig7.deinterleave_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(deinterleave_sptr self, long min_output_buffer)
        set_min_output_buffer(deinterleave_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.deinterleave_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full_var(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full_var(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(deinterleave_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.deinterleave_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(deinterleave_sptr self)"""
        return _blocks_swig7.deinterleave_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(deinterleave_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.deinterleave_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(deinterleave_sptr self, int priority) -> int"""
        return _blocks_swig7.deinterleave_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_name(self)


    def symbol_name(self):
        """symbol_name(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(deinterleave_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.deinterleave_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(deinterleave_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.deinterleave_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(deinterleave_sptr self) -> long"""
        return _blocks_swig7.deinterleave_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(deinterleave_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.deinterleave_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(deinterleave_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.deinterleave_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(deinterleave_sptr self, std::string name)"""
        return _blocks_swig7.deinterleave_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(deinterleave_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.deinterleave_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(deinterleave_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(deinterleave_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(deinterleave_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_subscribers(self, which_port)

deinterleave_sptr_swigregister = _blocks_swig7.deinterleave_sptr_swigregister
deinterleave_sptr_swigregister(deinterleave_sptr)


deinterleave_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
deinterleave = deinterleave.make;

class divide_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::divide_ff)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::divide_ff)> self) -> divide_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::divide_ff)> self, divide_ff p) -> divide_ff_sptr
        """
        this = _blocks_swig7.new_divide_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(divide_ff_sptr self) -> divide_ff"""
        return _blocks_swig7.divide_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_divide_ff_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(divide_ff_sptr self, size_t vlen=1) -> divide_ff_sptr"""
        return _blocks_swig7.divide_ff_sptr_make(self, vlen)


    def history(self):
        """history(divide_ff_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(divide_ff_sptr self, int which, int delay)
        declare_sample_delay(divide_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(divide_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(divide_ff_sptr self) -> double"""
        return _blocks_swig7.divide_ff_sptr_relative_rate(self)


    def start(self):
        """start(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_start(self)


    def stop(self):
        """stop(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(divide_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(divide_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(divide_ff_sptr self, int m)"""
        return _blocks_swig7.divide_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(divide_ff_sptr self)"""
        return _blocks_swig7.divide_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(divide_ff_sptr self, int m)"""
        return _blocks_swig7.divide_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(divide_ff_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(divide_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(divide_ff_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(divide_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(divide_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(divide_ff_sptr self)"""
        return _blocks_swig7.divide_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(divide_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(divide_ff_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(divide_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(divide_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(divide_ff_sptr self) -> long"""
        return _blocks_swig7.divide_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(divide_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(divide_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(divide_ff_sptr self, std::string name)"""
        return _blocks_swig7.divide_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(divide_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.divide_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(divide_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(divide_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(divide_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_subscribers(self, which_port)

divide_ff_sptr_swigregister = _blocks_swig7.divide_ff_sptr_swigregister
divide_ff_sptr_swigregister(divide_ff_sptr)


divide_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ff = divide_ff.make;

class divide_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::divide_ss)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::divide_ss)> self) -> divide_ss_sptr
        __init__(boost::shared_ptr<(gr::blocks::divide_ss)> self, divide_ss p) -> divide_ss_sptr
        """
        this = _blocks_swig7.new_divide_ss_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(divide_ss_sptr self) -> divide_ss"""
        return _blocks_swig7.divide_ss_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_divide_ss_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(divide_ss_sptr self, size_t vlen=1) -> divide_ss_sptr"""
        return _blocks_swig7.divide_ss_sptr_make(self, vlen)


    def history(self):
        """history(divide_ss_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ss_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(divide_ss_sptr self, int which, int delay)
        declare_sample_delay(divide_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ss_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(divide_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ss_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(divide_ss_sptr self) -> double"""
        return _blocks_swig7.divide_ss_sptr_relative_rate(self)


    def start(self):
        """start(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_start(self)


    def stop(self):
        """stop(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(divide_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(divide_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(divide_ss_sptr self, int m)"""
        return _blocks_swig7.divide_ss_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(divide_ss_sptr self)"""
        return _blocks_swig7.divide_ss_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(divide_ss_sptr self, int m)"""
        return _blocks_swig7.divide_ss_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(divide_ss_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ss_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(divide_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ss_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(divide_ss_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ss_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(divide_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ss_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(divide_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ss_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(divide_ss_sptr self)"""
        return _blocks_swig7.divide_ss_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(divide_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ss_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(divide_ss_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ss_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_name(self)


    def symbol_name(self):
        """symbol_name(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(divide_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ss_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(divide_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ss_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(divide_ss_sptr self) -> long"""
        return _blocks_swig7.divide_ss_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(divide_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ss_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(divide_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ss_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(divide_ss_sptr self, std::string name)"""
        return _blocks_swig7.divide_ss_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(divide_ss_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.divide_ss_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(divide_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(divide_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(divide_ss_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_subscribers(self, which_port)

divide_ss_sptr_swigregister = _blocks_swig7.divide_ss_sptr_swigregister
divide_ss_sptr_swigregister(divide_ss_sptr)


divide_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ss = divide_ss.make;

class divide_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::divide_ii)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::divide_ii)> self) -> divide_ii_sptr
        __init__(boost::shared_ptr<(gr::blocks::divide_ii)> self, divide_ii p) -> divide_ii_sptr
        """
        this = _blocks_swig7.new_divide_ii_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(divide_ii_sptr self) -> divide_ii"""
        return _blocks_swig7.divide_ii_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_divide_ii_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(divide_ii_sptr self, size_t vlen=1) -> divide_ii_sptr"""
        return _blocks_swig7.divide_ii_sptr_make(self, vlen)


    def history(self):
        """history(divide_ii_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ii_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(divide_ii_sptr self, int which, int delay)
        declare_sample_delay(divide_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ii_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(divide_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ii_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(divide_ii_sptr self) -> double"""
        return _blocks_swig7.divide_ii_sptr_relative_rate(self)


    def start(self):
        """start(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_start(self)


    def stop(self):
        """stop(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(divide_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(divide_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(divide_ii_sptr self, int m)"""
        return _blocks_swig7.divide_ii_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(divide_ii_sptr self)"""
        return _blocks_swig7.divide_ii_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(divide_ii_sptr self, int m)"""
        return _blocks_swig7.divide_ii_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(divide_ii_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ii_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(divide_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ii_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(divide_ii_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ii_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(divide_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ii_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(divide_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ii_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(divide_ii_sptr self)"""
        return _blocks_swig7.divide_ii_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(divide_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ii_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(divide_ii_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ii_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_name(self)


    def symbol_name(self):
        """symbol_name(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(divide_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ii_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(divide_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ii_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(divide_ii_sptr self) -> long"""
        return _blocks_swig7.divide_ii_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(divide_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ii_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(divide_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ii_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(divide_ii_sptr self, std::string name)"""
        return _blocks_swig7.divide_ii_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(divide_ii_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.divide_ii_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(divide_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(divide_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(divide_ii_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_subscribers(self, which_port)

divide_ii_sptr_swigregister = _blocks_swig7.divide_ii_sptr_swigregister
divide_ii_sptr_swigregister(divide_ii_sptr)


divide_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ii = divide_ii.make;

class divide_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::divide_cc)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::divide_cc)> self) -> divide_cc_sptr
        __init__(boost::shared_ptr<(gr::blocks::divide_cc)> self, divide_cc p) -> divide_cc_sptr
        """
        this = _blocks_swig7.new_divide_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(divide_cc_sptr self) -> divide_cc"""
        return _blocks_swig7.divide_cc_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_divide_cc_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(divide_cc_sptr self, size_t vlen=1) -> divide_cc_sptr"""
        return _blocks_swig7.divide_cc_sptr_make(self, vlen)


    def history(self):
        """history(divide_cc_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(divide_cc_sptr self, int which, int delay)
        declare_sample_delay(divide_cc_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(divide_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(divide_cc_sptr self) -> double"""
        return _blocks_swig7.divide_cc_sptr_relative_rate(self)


    def start(self):
        """start(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_start(self)


    def stop(self):
        """stop(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(divide_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(divide_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(divide_cc_sptr self, int m)"""
        return _blocks_swig7.divide_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(divide_cc_sptr self)"""
        return _blocks_swig7.divide_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(divide_cc_sptr self, int m)"""
        return _blocks_swig7.divide_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(divide_cc_sptr self, int i) -> long"""
        return _blocks_swig7.divide_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(divide_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_cc_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(divide_cc_sptr self, int i) -> long"""
        return _blocks_swig7.divide_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(divide_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_cc_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(divide_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(divide_cc_sptr self)"""
        return _blocks_swig7.divide_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(divide_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(divide_cc_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(divide_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(divide_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(divide_cc_sptr self) -> long"""
        return _blocks_swig7.divide_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(divide_cc_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(divide_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(divide_cc_sptr self, std::string name)"""
        return _blocks_swig7.divide_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(divide_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.divide_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(divide_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(divide_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(divide_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_subscribers(self, which_port)

divide_cc_sptr_swigregister = _blocks_swig7.divide_cc_sptr_swigregister
divide_cc_sptr_swigregister(divide_cc_sptr)


divide_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_cc = divide_cc.make;

class exponentiate_const_cci_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::exponentiate_const_cci)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::exponentiate_const_cci)> self) -> exponentiate_const_cci_sptr
        __init__(boost::shared_ptr<(gr::blocks::exponentiate_const_cci)> self, exponentiate_const_cci p) -> exponentiate_const_cci_sptr
        """
        this = _blocks_swig7.new_exponentiate_const_cci_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(exponentiate_const_cci_sptr self) -> exponentiate_const_cci"""
        return _blocks_swig7.exponentiate_const_cci_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_exponentiate_const_cci_sptr
    __del__ = lambda self: None

    def make(self, exponent, vlen=1):
        """make(exponentiate_const_cci_sptr self, int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_make(self, exponent, vlen)


    def set_exponent(self, exponent):
        """set_exponent(exponentiate_const_cci_sptr self, int exponent)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_exponent(self, exponent)


    def history(self):
        """history(exponentiate_const_cci_sptr self) -> unsigned int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(exponentiate_const_cci_sptr self, int which, int delay)
        declare_sample_delay(exponentiate_const_cci_sptr self, unsigned int delay)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(exponentiate_const_cci_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(exponentiate_const_cci_sptr self) -> double"""
        return _blocks_swig7.exponentiate_const_cci_sptr_relative_rate(self)


    def start(self):
        """start(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_start(self)


    def stop(self):
        """stop(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(exponentiate_const_cci_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(exponentiate_const_cci_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(exponentiate_const_cci_sptr self, int m)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(exponentiate_const_cci_sptr self)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(exponentiate_const_cci_sptr self, int m)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(exponentiate_const_cci_sptr self, int i) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(exponentiate_const_cci_sptr self, long max_output_buffer)
        set_max_output_buffer(exponentiate_const_cci_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(exponentiate_const_cci_sptr self, int i) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(exponentiate_const_cci_sptr self, long min_output_buffer)
        set_min_output_buffer(exponentiate_const_cci_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full_avg(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full_var(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full_avg(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full_var(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(exponentiate_const_cci_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(exponentiate_const_cci_sptr self)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(exponentiate_const_cci_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.exponentiate_const_cci_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(exponentiate_const_cci_sptr self, int priority) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_name(self)


    def symbol_name(self):
        """symbol_name(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(exponentiate_const_cci_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(exponentiate_const_cci_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(exponentiate_const_cci_sptr self) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(exponentiate_const_cci_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(exponentiate_const_cci_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(exponentiate_const_cci_sptr self, std::string name)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(exponentiate_const_cci_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.exponentiate_const_cci_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(exponentiate_const_cci_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(exponentiate_const_cci_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(exponentiate_const_cci_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_subscribers(self, which_port)

exponentiate_const_cci_sptr_swigregister = _blocks_swig7.exponentiate_const_cci_sptr_swigregister
exponentiate_const_cci_sptr_swigregister(exponentiate_const_cci_sptr)


exponentiate_const_cci_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
exponentiate_const_cci = exponentiate_const_cci.make;

class skiphead_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::skiphead)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::skiphead)> self) -> skiphead_sptr
        __init__(boost::shared_ptr<(gr::blocks::skiphead)> self, skiphead p) -> skiphead_sptr
        """
        this = _blocks_swig7.new_skiphead_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(skiphead_sptr self) -> skiphead"""
        return _blocks_swig7.skiphead_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_skiphead_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nitems_to_skip):
        """make(skiphead_sptr self, size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig7.skiphead_sptr_make(self, itemsize, nitems_to_skip)


    def history(self):
        """history(skiphead_sptr self) -> unsigned int"""
        return _blocks_swig7.skiphead_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(skiphead_sptr self, int which, int delay)
        declare_sample_delay(skiphead_sptr self, unsigned int delay)
        """
        return _blocks_swig7.skiphead_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(skiphead_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.skiphead_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(skiphead_sptr self) -> double"""
        return _blocks_swig7.skiphead_sptr_relative_rate(self)


    def start(self):
        """start(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_start(self)


    def stop(self):
        """stop(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(skiphead_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(skiphead_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig7.skiphead_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(skiphead_sptr self)"""
        return _blocks_swig7.skiphead_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig7.skiphead_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig7.skiphead_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(skiphead_sptr self, long max_output_buffer)
        set_max_output_buffer(skiphead_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.skiphead_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig7.skiphead_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(skiphead_sptr self, long min_output_buffer)
        set_min_output_buffer(skiphead_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.skiphead_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(skiphead_sptr self, int which) -> float
        pc_input_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(skiphead_sptr self, int which) -> float
        pc_output_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(skiphead_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.skiphead_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(skiphead_sptr self)"""
        return _blocks_swig7.skiphead_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(skiphead_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.skiphead_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(skiphead_sptr self, int priority) -> int"""
        return _blocks_swig7.skiphead_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_name(self)


    def symbol_name(self):
        """symbol_name(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.skiphead_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.skiphead_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(skiphead_sptr self) -> long"""
        return _blocks_swig7.skiphead_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(skiphead_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.skiphead_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(skiphead_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.skiphead_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(skiphead_sptr self, std::string name)"""
        return _blocks_swig7.skiphead_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(skiphead_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.skiphead_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(skiphead_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.skiphead_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(skiphead_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.skiphead_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(skiphead_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.skiphead_sptr_message_subscribers(self, which_port)

skiphead_sptr_swigregister = _blocks_swig7.skiphead_sptr_swigregister
skiphead_sptr_swigregister(skiphead_sptr)


skiphead_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
skiphead = skiphead.make;

class stream_mux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_mux)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_mux)> self) -> stream_mux_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_mux)> self, stream_mux p) -> stream_mux_sptr
        """
        this = _blocks_swig7.new_stream_mux_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(stream_mux_sptr self) -> stream_mux"""
        return _blocks_swig7.stream_mux_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_stream_mux_sptr
    __del__ = lambda self: None

    def make(self, itemsize, lengths):
        """make(stream_mux_sptr self, size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig7.stream_mux_sptr_make(self, itemsize, lengths)


    def history(self):
        """history(stream_mux_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_mux_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_mux_sptr self, int which, int delay)
        declare_sample_delay(stream_mux_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_mux_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_mux_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_mux_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_mux_sptr self) -> double"""
        return _blocks_swig7.stream_mux_sptr_relative_rate(self)


    def start(self):
        """start(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_start(self)


    def stop(self):
        """stop(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig7.stream_mux_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_mux_sptr self)"""
        return _blocks_swig7.stream_mux_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig7.stream_mux_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig7.stream_mux_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_mux_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_mux_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig7.stream_mux_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_mux_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_mux_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_mux_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_mux_sptr self)"""
        return _blocks_swig7.stream_mux_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_mux_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_mux_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_mux_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_mux_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_mux_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_mux_sptr self) -> long"""
        return _blocks_swig7.stream_mux_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_mux_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_mux_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_mux_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_mux_sptr self, std::string name)"""
        return _blocks_swig7.stream_mux_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_mux_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.stream_mux_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_mux_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_subscribers(self, which_port)

stream_mux_sptr_swigregister = _blocks_swig7.stream_mux_sptr_swigregister
stream_mux_sptr_swigregister(stream_mux_sptr)


stream_mux_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_mux = stream_mux.make;

class stream_to_streams_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_streams)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_streams)> self) -> stream_to_streams_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_streams)> self, stream_to_streams p) -> stream_to_streams_sptr
        """
        this = _blocks_swig7.new_stream_to_streams_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_streams_sptr self) -> stream_to_streams"""
        return _blocks_swig7.stream_to_streams_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_stream_to_streams_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(stream_to_streams_sptr self, size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(stream_to_streams_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_streams_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_streams_sptr self, int which, int delay)
        declare_sample_delay(stream_to_streams_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_streams_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_streams_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_streams_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_streams_sptr self) -> double"""
        return _blocks_swig7.stream_to_streams_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_start(self)


    def stop(self):
        """stop(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_streams_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_streams_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig7.stream_to_streams_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_streams_sptr self)"""
        return _blocks_swig7.stream_to_streams_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig7.stream_to_streams_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_streams_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_streams_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_streams_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_streams_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_streams_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_streams_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_streams_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_streams_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_streams_sptr self)"""
        return _blocks_swig7.stream_to_streams_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_streams_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_streams_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_streams_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_streams_sptr self) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_streams_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_streams_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_streams_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_streams_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_streams_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.stream_to_streams_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_streams_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_subscribers(self, which_port)

stream_to_streams_sptr_swigregister = _blocks_swig7.stream_to_streams_sptr_swigregister
stream_to_streams_sptr_swigregister(stream_to_streams_sptr)


stream_to_streams_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_streams = stream_to_streams.make;

class stream_to_tagged_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> self) -> stream_to_tagged_stream_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> self, stream_to_tagged_stream p) -> stream_to_tagged_stream_sptr
        """
        this = _blocks_swig7.new_stream_to_tagged_stream_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_tagged_stream_sptr self) -> stream_to_tagged_stream"""
        return _blocks_swig7.stream_to_tagged_stream_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_stream_to_tagged_stream_sptr
    __del__ = lambda self: None

    def make(self, itemsize, vlen, packet_len, len_tag_key):
        """make(stream_to_tagged_stream_sptr self, size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_make(self, itemsize, vlen, packet_len, len_tag_key)


    def set_packet_len(self, packet_len):
        """set_packet_len(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_packet_len(self, packet_len)


    def set_packet_len_pmt(self, packet_len):
        """set_packet_len_pmt(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_packet_len_pmt(self, packet_len)


    def history(self):
        """history(stream_to_tagged_stream_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_tagged_stream_sptr self, int which, int delay)
        declare_sample_delay(stream_to_tagged_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_tagged_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_tagged_stream_sptr self) -> double"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_start(self)


    def stop(self):
        """stop(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_tagged_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_tagged_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_tagged_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_tagged_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_tagged_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_tagged_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_tagged_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_tagged_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_tagged_stream_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_tagged_stream_sptr self) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_tagged_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_tagged_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_tagged_stream_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_tagged_stream_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_tagged_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_tagged_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_tagged_stream_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_subscribers(self, which_port)

stream_to_tagged_stream_sptr_swigregister = _blocks_swig7.stream_to_tagged_stream_sptr_swigregister
stream_to_tagged_stream_sptr_swigregister(stream_to_tagged_stream_sptr)


stream_to_tagged_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_tagged_stream = stream_to_tagged_stream.make;

class stream_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_vector)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_vector)> self) -> stream_to_vector_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_vector)> self, stream_to_vector p) -> stream_to_vector_sptr
        """
        this = _blocks_swig7.new_stream_to_vector_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_vector_sptr self) -> stream_to_vector"""
        return _blocks_swig7.stream_to_vector_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_stream_to_vector_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nitems_per_block):
        """make(stream_to_vector_sptr self, size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_make(self, itemsize, nitems_per_block)


    def history(self):
        """history(stream_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_vector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_vector_sptr self, int which, int delay)
        declare_sample_delay(stream_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_vector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_vector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_vector_sptr self) -> double"""
        return _blocks_swig7.stream_to_vector_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_start(self)


    def stop(self):
        """stop(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig7.stream_to_vector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_vector_sptr self)"""
        return _blocks_swig7.stream_to_vector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig7.stream_to_vector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_vector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_vector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_vector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_vector_sptr self)"""
        return _blocks_swig7.stream_to_vector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_vector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_vector_sptr self) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_vector_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_vector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_vector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.stream_to_vector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_vector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_subscribers(self, which_port)

stream_to_vector_sptr_swigregister = _blocks_swig7.stream_to_vector_sptr_swigregister
stream_to_vector_sptr_swigregister(stream_to_vector_sptr)


stream_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_vector = stream_to_vector.make;

class streams_to_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::streams_to_stream)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::streams_to_stream)> self) -> streams_to_stream_sptr
        __init__(boost::shared_ptr<(gr::blocks::streams_to_stream)> self, streams_to_stream p) -> streams_to_stream_sptr
        """
        this = _blocks_swig7.new_streams_to_stream_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(streams_to_stream_sptr self) -> streams_to_stream"""
        return _blocks_swig7.streams_to_stream_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_streams_to_stream_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(streams_to_stream_sptr self, size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(streams_to_stream_sptr self) -> unsigned int"""
        return _blocks_swig7.streams_to_stream_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(streams_to_stream_sptr self, int which, int delay)
        declare_sample_delay(streams_to_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig7.streams_to_stream_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(streams_to_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.streams_to_stream_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(streams_to_stream_sptr self) -> double"""
        return _blocks_swig7.streams_to_stream_sptr_relative_rate(self)


    def start(self):
        """start(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_start(self)


    def stop(self):
        """stop(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(streams_to_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(streams_to_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig7.streams_to_stream_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(streams_to_stream_sptr self)"""
        return _blocks_swig7.streams_to_stream_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig7.streams_to_stream_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(streams_to_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.streams_to_stream_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(streams_to_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.streams_to_stream_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(streams_to_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.streams_to_stream_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(streams_to_stream_sptr self)"""
        return _blocks_swig7.streams_to_stream_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(streams_to_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.streams_to_stream_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(streams_to_stream_sptr self, int priority) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_name(self)


    def symbol_name(self):
        """symbol_name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(streams_to_stream_sptr self) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(streams_to_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(streams_to_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(streams_to_stream_sptr self, std::string name)"""
        return _blocks_swig7.streams_to_stream_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(streams_to_stream_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.streams_to_stream_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(streams_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(streams_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(streams_to_stream_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_subscribers(self, which_port)

streams_to_stream_sptr_swigregister = _blocks_swig7.streams_to_stream_sptr_swigregister
streams_to_stream_sptr_swigregister(streams_to_stream_sptr)


streams_to_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
streams_to_stream = streams_to_stream.make;

class streams_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::streams_to_vector)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::streams_to_vector)> self) -> streams_to_vector_sptr
        __init__(boost::shared_ptr<(gr::blocks::streams_to_vector)> self, streams_to_vector p) -> streams_to_vector_sptr
        """
        this = _blocks_swig7.new_streams_to_vector_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(streams_to_vector_sptr self) -> streams_to_vector"""
        return _blocks_swig7.streams_to_vector_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_streams_to_vector_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(streams_to_vector_sptr self, size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(streams_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig7.streams_to_vector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(streams_to_vector_sptr self, int which, int delay)
        declare_sample_delay(streams_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig7.streams_to_vector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(streams_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.streams_to_vector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(streams_to_vector_sptr self) -> double"""
        return _blocks_swig7.streams_to_vector_sptr_relative_rate(self)


    def start(self):
        """start(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_start(self)


    def stop(self):
        """stop(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(streams_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(streams_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig7.streams_to_vector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(streams_to_vector_sptr self)"""
        return _blocks_swig7.streams_to_vector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig7.streams_to_vector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(streams_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.streams_to_vector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(streams_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.streams_to_vector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(streams_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.streams_to_vector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(streams_to_vector_sptr self)"""
        return _blocks_swig7.streams_to_vector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(streams_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.streams_to_vector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(streams_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(streams_to_vector_sptr self) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(streams_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(streams_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(streams_to_vector_sptr self, std::string name)"""
        return _blocks_swig7.streams_to_vector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(streams_to_vector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.streams_to_vector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(streams_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(streams_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(streams_to_vector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_subscribers(self, which_port)

streams_to_vector_sptr_swigregister = _blocks_swig7.streams_to_vector_sptr_swigregister
streams_to_vector_sptr_swigregister(streams_to_vector_sptr)


streams_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
streams_to_vector = streams_to_vector.make;

class tag_debug_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tag_debug)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tag_debug)> self) -> tag_debug_sptr
        __init__(boost::shared_ptr<(gr::blocks::tag_debug)> self, tag_debug p) -> tag_debug_sptr
        """
        this = _blocks_swig7.new_tag_debug_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tag_debug_sptr self) -> tag_debug"""
        return _blocks_swig7.tag_debug_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tag_debug_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tag_debug_sptr self, size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
        return _blocks_swig7.tag_debug_sptr_make(self, *args, **kwargs)


    def current_tags(self):
        """current_tags(tag_debug_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tag_debug_sptr_current_tags(self)


    def num_tags(self):
        """num_tags(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_num_tags(self)


    def set_display(self, d):
        """set_display(tag_debug_sptr self, bool d)"""
        return _blocks_swig7.tag_debug_sptr_set_display(self, d)


    def set_key_filter(self, key_filter):
        """set_key_filter(tag_debug_sptr self, std::string const & key_filter)"""
        return _blocks_swig7.tag_debug_sptr_set_key_filter(self, key_filter)


    def key_filter(self):
        """key_filter(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_key_filter(self)


    def history(self):
        """history(tag_debug_sptr self) -> unsigned int"""
        return _blocks_swig7.tag_debug_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tag_debug_sptr self, int which, int delay)
        declare_sample_delay(tag_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tag_debug_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tag_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tag_debug_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tag_debug_sptr self) -> double"""
        return _blocks_swig7.tag_debug_sptr_relative_rate(self)


    def start(self):
        """start(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_start(self)


    def stop(self):
        """stop(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tag_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tag_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig7.tag_debug_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tag_debug_sptr self)"""
        return _blocks_swig7.tag_debug_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig7.tag_debug_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig7.tag_debug_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tag_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tag_debug_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig7.tag_debug_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tag_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tag_debug_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tag_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tag_debug_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tag_debug_sptr self)"""
        return _blocks_swig7.tag_debug_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tag_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tag_debug_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tag_debug_sptr self, int priority) -> int"""
        return _blocks_swig7.tag_debug_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tag_debug_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tag_debug_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tag_debug_sptr self) -> long"""
        return _blocks_swig7.tag_debug_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tag_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tag_debug_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tag_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tag_debug_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tag_debug_sptr self, std::string name)"""
        return _blocks_swig7.tag_debug_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tag_debug_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tag_debug_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tag_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tag_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tag_debug_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_subscribers(self, which_port)

tag_debug_sptr_swigregister = _blocks_swig7.tag_debug_sptr_swigregister
tag_debug_sptr_swigregister(tag_debug_sptr)


tag_debug_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tag_debug = tag_debug.make;

class tagged_file_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_file_sink)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tagged_file_sink)> self) -> tagged_file_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_file_sink)> self, tagged_file_sink p) -> tagged_file_sink_sptr
        """
        this = _blocks_swig7.new_tagged_file_sink_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_file_sink_sptr self) -> tagged_file_sink"""
        return _blocks_swig7.tagged_file_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tagged_file_sink_sptr
    __del__ = lambda self: None

    def make(self, itemsize, samp_rate):
        """make(tagged_file_sink_sptr self, size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_make(self, itemsize, samp_rate)


    def history(self):
        """history(tagged_file_sink_sptr self) -> unsigned int"""
        return _blocks_swig7.tagged_file_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_file_sink_sptr self, int which, int delay)
        declare_sample_delay(tagged_file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tagged_file_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tagged_file_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_file_sink_sptr self) -> double"""
        return _blocks_swig7.tagged_file_sink_sptr_relative_rate(self)


    def start(self):
        """start(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_start(self)


    def stop(self):
        """stop(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_file_sink_sptr self)"""
        return _blocks_swig7.tagged_file_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tagged_file_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tagged_file_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_file_sink_sptr self)"""
        return _blocks_swig7.tagged_file_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tagged_file_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_file_sink_sptr self, int priority) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_file_sink_sptr self) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_file_sink_sptr self, std::string name)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_file_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tagged_file_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_file_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_subscribers(self, which_port)

tagged_file_sink_sptr_swigregister = _blocks_swig7.tagged_file_sink_sptr_swigregister
tagged_file_sink_sptr_swigregister(tagged_file_sink_sptr)


tagged_file_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tagged_file_sink = tagged_file_sink.make;

class tsb_vector_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> self) -> tsb_vector_sink_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> self, tsb_vector_sink_b p) -> tsb_vector_sink_b_sptr
        """
        this = _blocks_swig7.new_tsb_vector_sink_b_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_b_sptr self) -> tsb_vector_sink_b"""
        return _blocks_swig7.tsb_vector_sink_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_b_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_b_sptr self) -> std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > >"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_b_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_b_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_b_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_b_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_b_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_b_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_b_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_b_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_b_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_subscribers(self, which_port)

tsb_vector_sink_b_sptr_swigregister = _blocks_swig7.tsb_vector_sink_b_sptr_swigregister
tsb_vector_sink_b_sptr_swigregister(tsb_vector_sink_b_sptr)


tsb_vector_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_b = tsb_vector_sink_b.make;

class tsb_vector_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> self) -> tsb_vector_sink_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> self, tsb_vector_sink_c p) -> tsb_vector_sink_c_sptr
        """
        this = _blocks_swig7.new_tsb_vector_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_c_sptr self) -> tsb_vector_sink_c"""
        return _blocks_swig7.tsb_vector_sink_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_c_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_c_sptr self) -> gr_vector_vector_complexf"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_c_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_c_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_c_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_c_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_c_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_c_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_c_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_c_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_c_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_subscribers(self, which_port)

tsb_vector_sink_c_sptr_swigregister = _blocks_swig7.tsb_vector_sink_c_sptr_swigregister
tsb_vector_sink_c_sptr_swigregister(tsb_vector_sink_c_sptr)


tsb_vector_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_c = tsb_vector_sink_c.make;

class tsb_vector_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> self) -> tsb_vector_sink_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> self, tsb_vector_sink_f p) -> tsb_vector_sink_f_sptr
        """
        this = _blocks_swig7.new_tsb_vector_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_f_sptr self) -> tsb_vector_sink_f"""
        return _blocks_swig7.tsb_vector_sink_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_f_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_f_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_f_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_f_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_f_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_f_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_f_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_f_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_f_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_f_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_f_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_subscribers(self, which_port)

tsb_vector_sink_f_sptr_swigregister = _blocks_swig7.tsb_vector_sink_f_sptr_swigregister
tsb_vector_sink_f_sptr_swigregister(tsb_vector_sink_f_sptr)


tsb_vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_f = tsb_vector_sink_f.make;

class tsb_vector_sink_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> self) -> tsb_vector_sink_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> self, tsb_vector_sink_i p) -> tsb_vector_sink_i_sptr
        """
        this = _blocks_swig7.new_tsb_vector_sink_i_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_i_sptr self) -> tsb_vector_sink_i"""
        return _blocks_swig7.tsb_vector_sink_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_i_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_i_sptr self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_i_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_i_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_i_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_i_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_i_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_i_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_i_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_i_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_i_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_i_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_i_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_subscribers(self, which_port)

tsb_vector_sink_i_sptr_swigregister = _blocks_swig7.tsb_vector_sink_i_sptr_swigregister
tsb_vector_sink_i_sptr_swigregister(tsb_vector_sink_i_sptr)


tsb_vector_sink_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_i = tsb_vector_sink_i.make;

class tsb_vector_sink_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> self) -> tsb_vector_sink_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> self, tsb_vector_sink_s p) -> tsb_vector_sink_s_sptr
        """
        this = _blocks_swig7.new_tsb_vector_sink_s_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_s_sptr self) -> tsb_vector_sink_s"""
        return _blocks_swig7.tsb_vector_sink_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_s_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_s_sptr self) -> std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > >"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_s_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_s_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_s_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_s_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_s_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_s_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_s_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_s_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_s_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_s_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_s_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_subscribers(self, which_port)

tsb_vector_sink_s_sptr_swigregister = _blocks_swig7.tsb_vector_sink_s_sptr_swigregister
tsb_vector_sink_s_sptr_swigregister(tsb_vector_sink_s_sptr)


tsb_vector_sink_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_s = tsb_vector_sink_s.make;

class throttle_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::throttle)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::throttle)> self) -> throttle_sptr
        __init__(boost::shared_ptr<(gr::blocks::throttle)> self, throttle p) -> throttle_sptr
        """
        this = _blocks_swig7.new_throttle_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(throttle_sptr self) -> throttle"""
        return _blocks_swig7.throttle_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig7.delete_throttle_sptr
    __del__ = lambda self: None

    def make(self, itemsize, samples_per_sec, ignore_tags=True):
        """make(throttle_sptr self, size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig7.throttle_sptr_make(self, itemsize, samples_per_sec, ignore_tags)


    def set_sample_rate(self, rate):
        """set_sample_rate(throttle_sptr self, double rate)"""
        return _blocks_swig7.throttle_sptr_set_sample_rate(self, rate)


    def sample_rate(self):
        """sample_rate(throttle_sptr self) -> double"""
        return _blocks_swig7.throttle_sptr_sample_rate(self)


    def history(self):
        """history(throttle_sptr self) -> unsigned int"""
        return _blocks_swig7.throttle_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(throttle_sptr self, int which, int delay)
        declare_sample_delay(throttle_sptr self, unsigned int delay)
        """
        return _blocks_swig7.throttle_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(throttle_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.throttle_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(throttle_sptr self) -> double"""
        return _blocks_swig7.throttle_sptr_relative_rate(self)


    def start(self):
        """start(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_start(self)


    def stop(self):
        """stop(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(throttle_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(throttle_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig7.throttle_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(throttle_sptr self)"""
        return _blocks_swig7.throttle_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig7.throttle_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig7.throttle_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(throttle_sptr self, long max_output_buffer)
        set_max_output_buffer(throttle_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.throttle_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig7.throttle_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(throttle_sptr self, long min_output_buffer)
        set_min_output_buffer(throttle_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.throttle_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(throttle_sptr self, int which) -> float
        pc_input_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(throttle_sptr self, int which) -> float
        pc_input_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(throttle_sptr self, int which) -> float
        pc_input_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(throttle_sptr self, int which) -> float
        pc_output_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(throttle_sptr self, int which) -> float
        pc_output_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(throttle_sptr self, int which) -> float
        pc_output_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(throttle_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.throttle_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(throttle_sptr self)"""
        return _blocks_swig7.throttle_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(throttle_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.throttle_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(throttle_sptr self, int priority) -> int"""
        return _blocks_swig7.throttle_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_name(self)


    def symbol_name(self):
        """symbol_name(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.throttle_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.throttle_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(throttle_sptr self) -> long"""
        return _blocks_swig7.throttle_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(throttle_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.throttle_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(throttle_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.throttle_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(throttle_sptr self, std::string name)"""
        return _blocks_swig7.throttle_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(throttle_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig7.throttle_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(throttle_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.throttle_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(throttle_sptr self) -> swig_int_ptr"""
        return _blocks_swig7.throttle_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(throttle_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig7.throttle_sptr_message_subscribers(self, which_port)

throttle_sptr_swigregister = _blocks_swig7.throttle_sptr_swigregister
throttle_sptr_swigregister(throttle_sptr)


throttle_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
throttle = throttle.make;



