# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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
if 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_swig5', [dirname(__file__)])
        except ImportError:
            import _blocks_swig5
            return _blocks_swig5
        if fp is not None:
            try:
                _mod = imp.load_module('_blocks_swig5', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _blocks_swig5 = swig_import_helper()
    del swig_import_helper
else:
    import _blocks_swig5
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



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_swig5.high_res_timer_now()

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _blocks_swig5.high_res_timer_epoch()

_blocks_swig5.byte_t_swigconstant(_blocks_swig5)
byte_t = _blocks_swig5.byte_t

_blocks_swig5.float_t_swigconstant(_blocks_swig5)
float_t = _blocks_swig5.float_t

_blocks_swig5.complex_t_swigconstant(_blocks_swig5)
complex_t = _blocks_swig5.complex_t

def itemsize(type):
    """itemsize(gr::blocks::pdu::vector_type type) -> size_t"""
    return _blocks_swig5.itemsize(type)

def type_matches(type, v):
    """type_matches(gr::blocks::pdu::vector_type type, swig_int_ptr v) -> bool"""
    return _blocks_swig5.type_matches(type, v)

def make_pdu_vector(type, buf, items):
    """make_pdu_vector(gr::blocks::pdu::vector_type type, uint8_t const * buf, size_t items) -> swig_int_ptr"""
    return _blocks_swig5.make_pdu_vector(type, buf, items)

def type_from_pmt(vector):
    """type_from_pmt(swig_int_ptr vector) -> gr::blocks::pdu::vector_type"""
    return _blocks_swig5.type_from_pmt(vector)
class random_pdu(object):
    """Proxy of C++ gr::blocks::random_pdu 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(mintime, maxtime, byte_mask=0xFF, length_modulo=1):
        """make(int mintime, int maxtime, char byte_mask=0xFF, int length_modulo=1) -> random_pdu_sptr"""
        return _blocks_swig5.random_pdu_make(mintime, maxtime, byte_mask, length_modulo)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_random_pdu
    __del__ = lambda self: None
random_pdu_swigregister = _blocks_swig5.random_pdu_swigregister
random_pdu_swigregister(random_pdu)

def random_pdu_make(mintime, maxtime, byte_mask=0xFF, length_modulo=1):
    """random_pdu_make(int mintime, int maxtime, char byte_mask=0xFF, int length_modulo=1) -> random_pdu_sptr"""
    return _blocks_swig5.random_pdu_make(mintime, maxtime, byte_mask, length_modulo)

class regenerate_bb(object):
    """Proxy of C++ gr::blocks::regenerate_bb 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(period, max_regen=500):
        """make(int period, unsigned int max_regen=500) -> regenerate_bb_sptr"""
        return _blocks_swig5.regenerate_bb_make(period, max_regen)

    make = staticmethod(make)

    def set_max_regen(self, regen):
        """set_max_regen(regenerate_bb self, unsigned int regen)"""
        return _blocks_swig5.regenerate_bb_set_max_regen(self, regen)


    def set_period(self, period):
        """set_period(regenerate_bb self, int period)"""
        return _blocks_swig5.regenerate_bb_set_period(self, period)


    def max_regen(self):
        """max_regen(regenerate_bb self) -> unsigned int"""
        return _blocks_swig5.regenerate_bb_max_regen(self)


    def period(self):
        """period(regenerate_bb self) -> int"""
        return _blocks_swig5.regenerate_bb_period(self)

    __swig_destroy__ = _blocks_swig5.delete_regenerate_bb
    __del__ = lambda self: None
regenerate_bb_swigregister = _blocks_swig5.regenerate_bb_swigregister
regenerate_bb_swigregister(regenerate_bb)

def regenerate_bb_make(period, max_regen=500):
    """regenerate_bb_make(int period, unsigned int max_regen=500) -> regenerate_bb_sptr"""
    return _blocks_swig5.regenerate_bb_make(period, max_regen)

class repack_bits_bb(object):
    """Proxy of C++ gr::blocks::repack_bits_bb 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(int k, int l=8, std::string const & tsb_tag_key, bool align_output=False, gr::endianness_t endianness) -> repack_bits_bb_sptr"""
        return _blocks_swig5.repack_bits_bb_make(*args, **kwargs)

    make = staticmethod(make)

    def set_k_and_l(self, k, l):
        """set_k_and_l(repack_bits_bb self, int k, int l)"""
        return _blocks_swig5.repack_bits_bb_set_k_and_l(self, k, l)

    __swig_destroy__ = _blocks_swig5.delete_repack_bits_bb
    __del__ = lambda self: None
repack_bits_bb_swigregister = _blocks_swig5.repack_bits_bb_swigregister
repack_bits_bb_swigregister(repack_bits_bb)

def repack_bits_bb_make(*args, **kwargs):
    """repack_bits_bb_make(int k, int l=8, std::string const & tsb_tag_key, bool align_output=False, gr::endianness_t endianness) -> repack_bits_bb_sptr"""
    return _blocks_swig5.repack_bits_bb_make(*args, **kwargs)

class repeat(object):
    """Proxy of C++ gr::blocks::repeat 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, repeat):
        """make(size_t itemsize, int repeat) -> repeat_sptr"""
        return _blocks_swig5.repeat_make(itemsize, repeat)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_repeat
    __del__ = lambda self: None
repeat_swigregister = _blocks_swig5.repeat_swigregister
repeat_swigregister(repeat)

def repeat_make(itemsize, repeat):
    """repeat_make(size_t itemsize, int repeat) -> repeat_sptr"""
    return _blocks_swig5.repeat_make(itemsize, repeat)

class rms_cf(object):
    """Proxy of C++ gr::blocks::rms_cf 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(alpha=0.0001):
        """make(double alpha=0.0001) -> rms_cf_sptr"""
        return _blocks_swig5.rms_cf_make(alpha)

    make = staticmethod(make)

    def set_alpha(self, alpha):
        """set_alpha(rms_cf self, double alpha)"""
        return _blocks_swig5.rms_cf_set_alpha(self, alpha)

    __swig_destroy__ = _blocks_swig5.delete_rms_cf
    __del__ = lambda self: None
rms_cf_swigregister = _blocks_swig5.rms_cf_swigregister
rms_cf_swigregister(rms_cf)

def rms_cf_make(alpha=0.0001):
    """rms_cf_make(double alpha=0.0001) -> rms_cf_sptr"""
    return _blocks_swig5.rms_cf_make(alpha)

class rms_ff(object):
    """Proxy of C++ gr::blocks::rms_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 - class is abstract")
    __repr__ = _swig_repr

    def make(alpha=0.0001):
        """make(double alpha=0.0001) -> rms_ff_sptr"""
        return _blocks_swig5.rms_ff_make(alpha)

    make = staticmethod(make)

    def set_alpha(self, alpha):
        """set_alpha(rms_ff self, double alpha)"""
        return _blocks_swig5.rms_ff_set_alpha(self, alpha)

    __swig_destroy__ = _blocks_swig5.delete_rms_ff
    __del__ = lambda self: None
rms_ff_swigregister = _blocks_swig5.rms_ff_swigregister
rms_ff_swigregister(rms_ff)

def rms_ff_make(alpha=0.0001):
    """rms_ff_make(double alpha=0.0001) -> rms_ff_sptr"""
    return _blocks_swig5.rms_ff_make(alpha)

class rotator_cc(object):
    """Proxy of C++ gr::blocks::rotator_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 - class is abstract")
    __repr__ = _swig_repr

    def make(phase_inc=0.0):
        """make(double phase_inc=0.0) -> rotator_cc_sptr"""
        return _blocks_swig5.rotator_cc_make(phase_inc)

    make = staticmethod(make)

    def set_phase_inc(self, phase_inc):
        """set_phase_inc(rotator_cc self, double phase_inc)"""
        return _blocks_swig5.rotator_cc_set_phase_inc(self, phase_inc)

    __swig_destroy__ = _blocks_swig5.delete_rotator_cc
    __del__ = lambda self: None
rotator_cc_swigregister = _blocks_swig5.rotator_cc_swigregister
rotator_cc_swigregister(rotator_cc)

def rotator_cc_make(phase_inc=0.0):
    """rotator_cc_make(double phase_inc=0.0) -> rotator_cc_sptr"""
    return _blocks_swig5.rotator_cc_make(phase_inc)

class sample_and_hold_bb(object):
    """Proxy of C++ gr::blocks::sample_and_hold_bb 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():
        """make() -> sample_and_hold_bb_sptr"""
        return _blocks_swig5.sample_and_hold_bb_make()

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_bb
    __del__ = lambda self: None
sample_and_hold_bb_swigregister = _blocks_swig5.sample_and_hold_bb_swigregister
sample_and_hold_bb_swigregister(sample_and_hold_bb)

def sample_and_hold_bb_make():
    """sample_and_hold_bb_make() -> sample_and_hold_bb_sptr"""
    return _blocks_swig5.sample_and_hold_bb_make()

class sample_and_hold_ss(object):
    """Proxy of C++ gr::blocks::sample_and_hold_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():
        """make() -> sample_and_hold_ss_sptr"""
        return _blocks_swig5.sample_and_hold_ss_make()

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ss
    __del__ = lambda self: None
sample_and_hold_ss_swigregister = _blocks_swig5.sample_and_hold_ss_swigregister
sample_and_hold_ss_swigregister(sample_and_hold_ss)

def sample_and_hold_ss_make():
    """sample_and_hold_ss_make() -> sample_and_hold_ss_sptr"""
    return _blocks_swig5.sample_and_hold_ss_make()

class sample_and_hold_ii(object):
    """Proxy of C++ gr::blocks::sample_and_hold_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():
        """make() -> sample_and_hold_ii_sptr"""
        return _blocks_swig5.sample_and_hold_ii_make()

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ii
    __del__ = lambda self: None
sample_and_hold_ii_swigregister = _blocks_swig5.sample_and_hold_ii_swigregister
sample_and_hold_ii_swigregister(sample_and_hold_ii)

def sample_and_hold_ii_make():
    """sample_and_hold_ii_make() -> sample_and_hold_ii_sptr"""
    return _blocks_swig5.sample_and_hold_ii_make()

class sample_and_hold_ff(object):
    """Proxy of C++ gr::blocks::sample_and_hold_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():
        """make() -> sample_and_hold_ff_sptr"""
        return _blocks_swig5.sample_and_hold_ff_make()

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ff
    __del__ = lambda self: None
sample_and_hold_ff_swigregister = _blocks_swig5.sample_and_hold_ff_swigregister
sample_and_hold_ff_swigregister(sample_and_hold_ff)

def sample_and_hold_ff_make():
    """sample_and_hold_ff_make() -> sample_and_hold_ff_sptr"""
    return _blocks_swig5.sample_and_hold_ff_make()

class short_to_char(object):
    """Proxy of C++ gr::blocks::short_to_char 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) -> short_to_char_sptr"""
        return _blocks_swig5.short_to_char_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_short_to_char
    __del__ = lambda self: None
short_to_char_swigregister = _blocks_swig5.short_to_char_swigregister
short_to_char_swigregister(short_to_char)

def short_to_char_make(vlen=1):
    """short_to_char_make(size_t vlen=1) -> short_to_char_sptr"""
    return _blocks_swig5.short_to_char_make(vlen)

class short_to_float(object):
    """Proxy of C++ gr::blocks::short_to_float 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(vlen=1, scale=1.0):
        """make(size_t vlen=1, float scale=1.0) -> short_to_float_sptr"""
        return _blocks_swig5.short_to_float_make(vlen, scale)

    make = staticmethod(make)

    def scale(self):
        """scale(short_to_float self) -> float"""
        return _blocks_swig5.short_to_float_scale(self)


    def set_scale(self, scale):
        """set_scale(short_to_float self, float scale)"""
        return _blocks_swig5.short_to_float_set_scale(self, scale)

    __swig_destroy__ = _blocks_swig5.delete_short_to_float
    __del__ = lambda self: None
short_to_float_swigregister = _blocks_swig5.short_to_float_swigregister
short_to_float_swigregister(short_to_float)

def short_to_float_make(vlen=1, scale=1.0):
    """short_to_float_make(size_t vlen=1, float scale=1.0) -> short_to_float_sptr"""
    return _blocks_swig5.short_to_float_make(vlen, scale)

class socket_pdu(object):
    """Proxy of C++ gr::blocks::socket_pdu 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(type, addr, port, MTU=10000, tcp_no_delay=False):
        """make(std::string type, std::string addr, std::string port, int MTU=10000, bool tcp_no_delay=False) -> socket_pdu_sptr"""
        return _blocks_swig5.socket_pdu_make(type, addr, port, MTU, tcp_no_delay)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_socket_pdu
    __del__ = lambda self: None
socket_pdu_swigregister = _blocks_swig5.socket_pdu_swigregister
socket_pdu_swigregister(socket_pdu)

def socket_pdu_make(type, addr, port, MTU=10000, tcp_no_delay=False):
    """socket_pdu_make(std::string type, std::string addr, std::string port, int MTU=10000, bool tcp_no_delay=False) -> socket_pdu_sptr"""
    return _blocks_swig5.socket_pdu_make(type, addr, port, MTU, tcp_no_delay)

class stretch_ff(object):
    """Proxy of C++ gr::blocks::stretch_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 - class is abstract")
    __repr__ = _swig_repr

    def make(lo, vlen=1):
        """make(float lo, size_t vlen=1) -> stretch_ff_sptr"""
        return _blocks_swig5.stretch_ff_make(lo, vlen)

    make = staticmethod(make)

    def lo(self):
        """lo(stretch_ff self) -> float"""
        return _blocks_swig5.stretch_ff_lo(self)


    def set_lo(self, lo):
        """set_lo(stretch_ff self, float lo)"""
        return _blocks_swig5.stretch_ff_set_lo(self, lo)


    def vlen(self):
        """vlen(stretch_ff self) -> size_t"""
        return _blocks_swig5.stretch_ff_vlen(self)

    __swig_destroy__ = _blocks_swig5.delete_stretch_ff
    __del__ = lambda self: None
stretch_ff_swigregister = _blocks_swig5.stretch_ff_swigregister
stretch_ff_swigregister(stretch_ff)

def stretch_ff_make(lo, vlen=1):
    """stretch_ff_make(float lo, size_t vlen=1) -> stretch_ff_sptr"""
    return _blocks_swig5.stretch_ff_make(lo, vlen)

class sub_ff(object):
    """Proxy of C++ gr::blocks::sub_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) -> sub_ff_sptr"""
        return _blocks_swig5.sub_ff_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sub_ff
    __del__ = lambda self: None
sub_ff_swigregister = _blocks_swig5.sub_ff_swigregister
sub_ff_swigregister(sub_ff)

def sub_ff_make(vlen=1):
    """sub_ff_make(size_t vlen=1) -> sub_ff_sptr"""
    return _blocks_swig5.sub_ff_make(vlen)

class sub_ss(object):
    """Proxy of C++ gr::blocks::sub_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) -> sub_ss_sptr"""
        return _blocks_swig5.sub_ss_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sub_ss
    __del__ = lambda self: None
sub_ss_swigregister = _blocks_swig5.sub_ss_swigregister
sub_ss_swigregister(sub_ss)

def sub_ss_make(vlen=1):
    """sub_ss_make(size_t vlen=1) -> sub_ss_sptr"""
    return _blocks_swig5.sub_ss_make(vlen)

class sub_ii(object):
    """Proxy of C++ gr::blocks::sub_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) -> sub_ii_sptr"""
        return _blocks_swig5.sub_ii_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sub_ii
    __del__ = lambda self: None
sub_ii_swigregister = _blocks_swig5.sub_ii_swigregister
sub_ii_swigregister(sub_ii)

def sub_ii_make(vlen=1):
    """sub_ii_make(size_t vlen=1) -> sub_ii_sptr"""
    return _blocks_swig5.sub_ii_make(vlen)

class sub_cc(object):
    """Proxy of C++ gr::blocks::sub_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) -> sub_cc_sptr"""
        return _blocks_swig5.sub_cc_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_sub_cc
    __del__ = lambda self: None
sub_cc_swigregister = _blocks_swig5.sub_cc_swigregister
sub_cc_swigregister(sub_cc)

def sub_cc_make(vlen=1):
    """sub_cc_make(size_t vlen=1) -> sub_cc_sptr"""
    return _blocks_swig5.sub_cc_make(vlen)

class tag_gate(object):
    """Proxy of C++ gr::blocks::tag_gate 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 set_propagation(self, propagate_tags):
        """set_propagation(tag_gate self, bool propagate_tags)"""
        return _blocks_swig5.tag_gate_set_propagation(self, propagate_tags)


    def make(item_size, propagate_tags=False):
        """make(size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
        return _blocks_swig5.tag_gate_make(item_size, propagate_tags)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tag_gate
    __del__ = lambda self: None
tag_gate_swigregister = _blocks_swig5.tag_gate_swigregister
tag_gate_swigregister(tag_gate)

def tag_gate_make(item_size, propagate_tags=False):
    """tag_gate_make(size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
    return _blocks_swig5.tag_gate_make(item_size, propagate_tags)

class tagged_stream_align(object):
    """Proxy of C++ gr::blocks::tagged_stream_align 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, lengthtagname):
        """make(size_t itemsize, std::string const & lengthtagname) -> tagged_stream_align_sptr"""
        return _blocks_swig5.tagged_stream_align_make(itemsize, lengthtagname)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_align
    __del__ = lambda self: None
tagged_stream_align_swigregister = _blocks_swig5.tagged_stream_align_swigregister
tagged_stream_align_swigregister(tagged_stream_align)

def tagged_stream_align_make(itemsize, lengthtagname):
    """tagged_stream_align_make(size_t itemsize, std::string const & lengthtagname) -> tagged_stream_align_sptr"""
    return _blocks_swig5.tagged_stream_align_make(itemsize, lengthtagname)

class tagged_stream_mux(object):
    """Proxy of C++ gr::blocks::tagged_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, lengthtagname, tag_preserve_head_pos=0):
        """make(size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) -> tagged_stream_mux_sptr"""
        return _blocks_swig5.tagged_stream_mux_make(itemsize, lengthtagname, tag_preserve_head_pos)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_mux
    __del__ = lambda self: None
tagged_stream_mux_swigregister = _blocks_swig5.tagged_stream_mux_swigregister
tagged_stream_mux_swigregister(tagged_stream_mux)

def tagged_stream_mux_make(itemsize, lengthtagname, tag_preserve_head_pos=0):
    """tagged_stream_mux_make(size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) -> tagged_stream_mux_sptr"""
    return _blocks_swig5.tagged_stream_mux_make(itemsize, lengthtagname, tag_preserve_head_pos)

class tagged_stream_multiply_length(object):
    """Proxy of C++ gr::blocks::tagged_stream_multiply_length 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 set_scalar(self, scalar):
        """set_scalar(tagged_stream_multiply_length self, double scalar)"""
        return _blocks_swig5.tagged_stream_multiply_length_set_scalar(self, scalar)


    def make(itemsize, lengthtagname, scalar):
        """make(size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
        return _blocks_swig5.tagged_stream_multiply_length_make(itemsize, lengthtagname, scalar)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_multiply_length
    __del__ = lambda self: None
tagged_stream_multiply_length_swigregister = _blocks_swig5.tagged_stream_multiply_length_swigregister
tagged_stream_multiply_length_swigregister(tagged_stream_multiply_length)

def tagged_stream_multiply_length_make(itemsize, lengthtagname, scalar):
    """tagged_stream_multiply_length_make(size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
    return _blocks_swig5.tagged_stream_multiply_length_make(itemsize, lengthtagname, scalar)

class tagged_stream_to_pdu(object):
    """Proxy of C++ gr::blocks::tagged_stream_to_pdu 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(*args, **kwargs):
        """make(gr::blocks::pdu::vector_type type, std::string const & lengthtagname) -> tagged_stream_to_pdu_sptr"""
        return _blocks_swig5.tagged_stream_to_pdu_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_to_pdu
    __del__ = lambda self: None
tagged_stream_to_pdu_swigregister = _blocks_swig5.tagged_stream_to_pdu_swigregister
tagged_stream_to_pdu_swigregister(tagged_stream_to_pdu)

def tagged_stream_to_pdu_make(*args, **kwargs):
    """tagged_stream_to_pdu_make(gr::blocks::pdu::vector_type type, std::string const & lengthtagname) -> tagged_stream_to_pdu_sptr"""
    return _blocks_swig5.tagged_stream_to_pdu_make(*args, **kwargs)

class tags_strobe(object):
    """Proxy of C++ gr::blocks::tags_strobe 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, swig_int_ptr value, uint64_t nsamps, swig_int_ptr key) -> tags_strobe_sptr"""
        return _blocks_swig5.tags_strobe_make(*args, **kwargs)

    make = staticmethod(make)

    def set_value(self, value):
        """set_value(tags_strobe self, swig_int_ptr value)"""
        return _blocks_swig5.tags_strobe_set_value(self, value)


    def set_key(self, key):
        """set_key(tags_strobe self, swig_int_ptr key)"""
        return _blocks_swig5.tags_strobe_set_key(self, key)


    def value(self):
        """value(tags_strobe self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_value(self)


    def key(self):
        """key(tags_strobe self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_key(self)


    def set_nsamps(self, nsamps):
        """set_nsamps(tags_strobe self, uint64_t nsamps)"""
        return _blocks_swig5.tags_strobe_set_nsamps(self, nsamps)


    def nsamps(self):
        """nsamps(tags_strobe self) -> uint64_t"""
        return _blocks_swig5.tags_strobe_nsamps(self)

    __swig_destroy__ = _blocks_swig5.delete_tags_strobe
    __del__ = lambda self: None
tags_strobe_swigregister = _blocks_swig5.tags_strobe_swigregister
tags_strobe_swigregister(tags_strobe)

def tags_strobe_make(*args, **kwargs):
    """tags_strobe_make(size_t sizeof_stream_item, swig_int_ptr value, uint64_t nsamps, swig_int_ptr key) -> tags_strobe_sptr"""
    return _blocks_swig5.tags_strobe_make(*args, **kwargs)

class threshold_ff(object):
    """Proxy of C++ gr::blocks::threshold_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 - class is abstract")
    __repr__ = _swig_repr

    def make(lo, hi, initial_state=0):
        """make(float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
        return _blocks_swig5.threshold_ff_make(lo, hi, initial_state)

    make = staticmethod(make)

    def lo(self):
        """lo(threshold_ff self) -> float"""
        return _blocks_swig5.threshold_ff_lo(self)


    def set_lo(self, lo):
        """set_lo(threshold_ff self, float lo)"""
        return _blocks_swig5.threshold_ff_set_lo(self, lo)


    def hi(self):
        """hi(threshold_ff self) -> float"""
        return _blocks_swig5.threshold_ff_hi(self)


    def set_hi(self, hi):
        """set_hi(threshold_ff self, float hi)"""
        return _blocks_swig5.threshold_ff_set_hi(self, hi)


    def last_state(self):
        """last_state(threshold_ff self) -> float"""
        return _blocks_swig5.threshold_ff_last_state(self)


    def set_last_state(self, last_state):
        """set_last_state(threshold_ff self, float last_state)"""
        return _blocks_swig5.threshold_ff_set_last_state(self, last_state)

    __swig_destroy__ = _blocks_swig5.delete_threshold_ff
    __del__ = lambda self: None
threshold_ff_swigregister = _blocks_swig5.threshold_ff_swigregister
threshold_ff_swigregister(threshold_ff)

def threshold_ff_make(lo, hi, initial_state=0):
    """threshold_ff_make(float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
    return _blocks_swig5.threshold_ff_make(lo, hi, initial_state)

class transcendental(object):
    """Proxy of C++ gr::blocks::transcendental 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(*args, **kwargs):
        """make(std::string const & name, std::string const & type) -> transcendental_sptr"""
        return _blocks_swig5.transcendental_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_transcendental
    __del__ = lambda self: None
transcendental_swigregister = _blocks_swig5.transcendental_swigregister
transcendental_swigregister(transcendental)

def transcendental_make(*args, **kwargs):
    """transcendental_make(std::string const & name, std::string const & type) -> transcendental_sptr"""
    return _blocks_swig5.transcendental_make(*args, **kwargs)

class tuntap_pdu(object):
    """Proxy of C++ gr::blocks::tuntap_pdu 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(dev, MTU=10000, istunflag=False):
        """make(std::string dev, int MTU=10000, bool istunflag=False) -> tuntap_pdu_sptr"""
        return _blocks_swig5.tuntap_pdu_make(dev, MTU, istunflag)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_tuntap_pdu
    __del__ = lambda self: None
tuntap_pdu_swigregister = _blocks_swig5.tuntap_pdu_swigregister
tuntap_pdu_swigregister(tuntap_pdu)

def tuntap_pdu_make(dev, MTU=10000, istunflag=False):
    """tuntap_pdu_make(std::string dev, int MTU=10000, bool istunflag=False) -> tuntap_pdu_sptr"""
    return _blocks_swig5.tuntap_pdu_make(dev, MTU, istunflag)

class uchar_to_float(object):
    """Proxy of C++ gr::blocks::uchar_to_float 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():
        """make() -> uchar_to_float_sptr"""
        return _blocks_swig5.uchar_to_float_make()

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_uchar_to_float
    __del__ = lambda self: None
uchar_to_float_swigregister = _blocks_swig5.uchar_to_float_swigregister
uchar_to_float_swigregister(uchar_to_float)

def uchar_to_float_make():
    """uchar_to_float_make() -> uchar_to_float_sptr"""
    return _blocks_swig5.uchar_to_float_make()

class udp_sink(object):
    """Proxy of C++ gr::blocks::udp_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 - class is abstract")
    __repr__ = _swig_repr

    def make(itemsize, host, port, payload_size=1472, eof=True):
        """make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
        return _blocks_swig5.udp_sink_make(itemsize, host, port, payload_size, eof)

    make = staticmethod(make)

    def payload_size(self):
        """payload_size(udp_sink self) -> int"""
        return _blocks_swig5.udp_sink_payload_size(self)


    def connect(self, host, port):
        """connect(udp_sink self, std::string const & host, int port)"""
        return _blocks_swig5.udp_sink_connect(self, host, port)


    def disconnect(self):
        """disconnect(udp_sink self)"""
        return _blocks_swig5.udp_sink_disconnect(self)

    __swig_destroy__ = _blocks_swig5.delete_udp_sink
    __del__ = lambda self: None
udp_sink_swigregister = _blocks_swig5.udp_sink_swigregister
udp_sink_swigregister(udp_sink)

def udp_sink_make(itemsize, host, port, payload_size=1472, eof=True):
    """udp_sink_make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
    return _blocks_swig5.udp_sink_make(itemsize, host, port, payload_size, eof)

class udp_source(object):
    """Proxy of C++ gr::blocks::udp_source 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, host, port, payload_size=1472, eof=True):
        """make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_source_sptr"""
        return _blocks_swig5.udp_source_make(itemsize, host, port, payload_size, eof)

    make = staticmethod(make)

    def connect(self, host, port):
        """connect(udp_source self, std::string const & host, int port)"""
        return _blocks_swig5.udp_source_connect(self, host, port)


    def disconnect(self):
        """disconnect(udp_source self)"""
        return _blocks_swig5.udp_source_disconnect(self)


    def payload_size(self):
        """payload_size(udp_source self) -> int"""
        return _blocks_swig5.udp_source_payload_size(self)


    def get_port(self):
        """get_port(udp_source self) -> int"""
        return _blocks_swig5.udp_source_get_port(self)

    __swig_destroy__ = _blocks_swig5.delete_udp_source
    __del__ = lambda self: None
udp_source_swigregister = _blocks_swig5.udp_source_swigregister
udp_source_swigregister(udp_source)

def udp_source_make(itemsize, host, port, payload_size=1472, eof=True):
    """udp_source_make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_source_sptr"""
    return _blocks_swig5.udp_source_make(itemsize, host, port, payload_size, eof)

class unpack_k_bits(object):
    """Proxy of C++ gr::blocks::kernel::unpack_k_bits 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, k):
        """__init__(gr::blocks::kernel::unpack_k_bits self, unsigned int k) -> unpack_k_bits"""
        this = _blocks_swig5.new_unpack_k_bits(k)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _blocks_swig5.delete_unpack_k_bits
    __del__ = lambda self: None

    def unpack(self, bits, bytes, nbytes):
        """unpack(unpack_k_bits self, unsigned char * bits, unsigned char const * bytes, int nbytes)"""
        return _blocks_swig5.unpack_k_bits_unpack(self, bits, bytes, nbytes)


    def unpack_rev(self, bits, bytes, nbytes):
        """unpack_rev(unpack_k_bits self, unsigned char * bits, unsigned char const * bytes, int nbytes)"""
        return _blocks_swig5.unpack_k_bits_unpack_rev(self, bits, bytes, nbytes)


    def k(self):
        """k(unpack_k_bits self) -> int"""
        return _blocks_swig5.unpack_k_bits_k(self)

unpack_k_bits_swigregister = _blocks_swig5.unpack_k_bits_swigregister
unpack_k_bits_swigregister(unpack_k_bits)

class unpack_k_bits_bb(object):
    """Proxy of C++ gr::blocks::unpack_k_bits_bb 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(k):
        """make(unsigned int k) -> unpack_k_bits_bb_sptr"""
        return _blocks_swig5.unpack_k_bits_bb_make(k)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_unpack_k_bits_bb
    __del__ = lambda self: None
unpack_k_bits_bb_swigregister = _blocks_swig5.unpack_k_bits_bb_swigregister
unpack_k_bits_bb_swigregister(unpack_k_bits_bb)

def unpack_k_bits_bb_make(k):
    """unpack_k_bits_bb_make(unsigned int k) -> unpack_k_bits_bb_sptr"""
    return _blocks_swig5.unpack_k_bits_bb_make(k)

class unpacked_to_packed_bb(object):
    """Proxy of C++ gr::blocks::unpacked_to_packed_bb 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(bits_per_chunk, endianness):
        """make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
        return _blocks_swig5.unpacked_to_packed_bb_make(bits_per_chunk, endianness)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_bb
    __del__ = lambda self: None
unpacked_to_packed_bb_swigregister = _blocks_swig5.unpacked_to_packed_bb_swigregister
unpacked_to_packed_bb_swigregister(unpacked_to_packed_bb)

def unpacked_to_packed_bb_make(bits_per_chunk, endianness):
    """unpacked_to_packed_bb_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
    return _blocks_swig5.unpacked_to_packed_bb_make(bits_per_chunk, endianness)

class unpacked_to_packed_ss(object):
    """Proxy of C++ gr::blocks::unpacked_to_packed_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(bits_per_chunk, endianness):
        """make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
        return _blocks_swig5.unpacked_to_packed_ss_make(bits_per_chunk, endianness)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_ss
    __del__ = lambda self: None
unpacked_to_packed_ss_swigregister = _blocks_swig5.unpacked_to_packed_ss_swigregister
unpacked_to_packed_ss_swigregister(unpacked_to_packed_ss)

def unpacked_to_packed_ss_make(bits_per_chunk, endianness):
    """unpacked_to_packed_ss_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
    return _blocks_swig5.unpacked_to_packed_ss_make(bits_per_chunk, endianness)

class unpacked_to_packed_ii(object):
    """Proxy of C++ gr::blocks::unpacked_to_packed_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(bits_per_chunk, endianness):
        """make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
        return _blocks_swig5.unpacked_to_packed_ii_make(bits_per_chunk, endianness)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_ii
    __del__ = lambda self: None
unpacked_to_packed_ii_swigregister = _blocks_swig5.unpacked_to_packed_ii_swigregister
unpacked_to_packed_ii_swigregister(unpacked_to_packed_ii)

def unpacked_to_packed_ii_make(bits_per_chunk, endianness):
    """unpacked_to_packed_ii_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
    return _blocks_swig5.unpacked_to_packed_ii_make(bits_per_chunk, endianness)

class vco_f(object):
    """Proxy of C++ gr::blocks::vco_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")
    __repr__ = _swig_repr

    def make(sampling_rate, sensitivity, amplitude):
        """make(double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
        return _blocks_swig5.vco_f_make(sampling_rate, sensitivity, amplitude)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_vco_f
    __del__ = lambda self: None
vco_f_swigregister = _blocks_swig5.vco_f_swigregister
vco_f_swigregister(vco_f)

def vco_f_make(sampling_rate, sensitivity, amplitude):
    """vco_f_make(double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
    return _blocks_swig5.vco_f_make(sampling_rate, sensitivity, amplitude)

class vco_c(object):
    """Proxy of C++ gr::blocks::vco_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")
    __repr__ = _swig_repr

    def make(sampling_rate, sensitivity, amplitude):
        """make(double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
        return _blocks_swig5.vco_c_make(sampling_rate, sensitivity, amplitude)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_vco_c
    __del__ = lambda self: None
vco_c_swigregister = _blocks_swig5.vco_c_swigregister
vco_c_swigregister(vco_c)

def vco_c_make(sampling_rate, sensitivity, amplitude):
    """vco_c_make(double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
    return _blocks_swig5.vco_c_make(sampling_rate, sensitivity, amplitude)

class xor_bb(object):
    """Proxy of C++ gr::blocks::xor_bb 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) -> xor_bb_sptr"""
        return _blocks_swig5.xor_bb_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_xor_bb
    __del__ = lambda self: None
xor_bb_swigregister = _blocks_swig5.xor_bb_swigregister
xor_bb_swigregister(xor_bb)

def xor_bb_make(vlen=1):
    """xor_bb_make(size_t vlen=1) -> xor_bb_sptr"""
    return _blocks_swig5.xor_bb_make(vlen)

class xor_ss(object):
    """Proxy of C++ gr::blocks::xor_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) -> xor_ss_sptr"""
        return _blocks_swig5.xor_ss_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_xor_ss
    __del__ = lambda self: None
xor_ss_swigregister = _blocks_swig5.xor_ss_swigregister
xor_ss_swigregister(xor_ss)

def xor_ss_make(vlen=1):
    """xor_ss_make(size_t vlen=1) -> xor_ss_sptr"""
    return _blocks_swig5.xor_ss_make(vlen)

class xor_ii(object):
    """Proxy of C++ gr::blocks::xor_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) -> xor_ii_sptr"""
        return _blocks_swig5.xor_ii_make(vlen)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig5.delete_xor_ii
    __del__ = lambda self: None
xor_ii_swigregister = _blocks_swig5.xor_ii_swigregister
xor_ii_swigregister(xor_ii)

def xor_ii_make(vlen=1):
    """xor_ii_make(size_t vlen=1) -> xor_ii_sptr"""
    return _blocks_swig5.xor_ii_make(vlen)

class random_pdu_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::random_pdu)> 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::random_pdu)> self) -> random_pdu_sptr
        __init__(boost::shared_ptr<(gr::blocks::random_pdu)> self, random_pdu p) -> random_pdu_sptr
        """
        this = _blocks_swig5.new_random_pdu_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(random_pdu_sptr self) -> random_pdu"""
        return _blocks_swig5.random_pdu_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_random_pdu_sptr
    __del__ = lambda self: None

    def make(self, mintime, maxtime, byte_mask=0xFF, length_modulo=1):
        """make(random_pdu_sptr self, int mintime, int maxtime, char byte_mask=0xFF, int length_modulo=1) -> random_pdu_sptr"""
        return _blocks_swig5.random_pdu_sptr_make(self, mintime, maxtime, byte_mask, length_modulo)


    def history(self):
        """history(random_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.random_pdu_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(random_pdu_sptr self, int which, int delay)
        declare_sample_delay(random_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig5.random_pdu_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(random_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.random_pdu_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(random_pdu_sptr self) -> double"""
        return _blocks_swig5.random_pdu_sptr_relative_rate(self)


    def start(self):
        """start(random_pdu_sptr self) -> bool"""
        return _blocks_swig5.random_pdu_sptr_start(self)


    def stop(self):
        """stop(random_pdu_sptr self) -> bool"""
        return _blocks_swig5.random_pdu_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(random_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.random_pdu_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(random_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.random_pdu_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(random_pdu_sptr self, int m)"""
        return _blocks_swig5.random_pdu_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(random_pdu_sptr self)"""
        return _blocks_swig5.random_pdu_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(random_pdu_sptr self) -> bool"""
        return _blocks_swig5.random_pdu_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(random_pdu_sptr self, int m)"""
        return _blocks_swig5.random_pdu_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(random_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.random_pdu_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(random_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(random_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.random_pdu_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(random_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.random_pdu_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(random_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(random_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.random_pdu_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(random_pdu_sptr self, int which) -> float
        pc_input_buffers_full(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(random_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(random_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(random_pdu_sptr self, int which) -> float
        pc_output_buffers_full(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(random_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(random_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(random_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.random_pdu_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(random_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.random_pdu_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(random_pdu_sptr self)"""
        return _blocks_swig5.random_pdu_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(random_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.random_pdu_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(random_pdu_sptr self, int priority) -> int"""
        return _blocks_swig5.random_pdu_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(random_pdu_sptr self) -> std::string"""
        return _blocks_swig5.random_pdu_sptr_name(self)


    def symbol_name(self):
        """symbol_name(random_pdu_sptr self) -> std::string"""
        return _blocks_swig5.random_pdu_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(random_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.random_pdu_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(random_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.random_pdu_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(random_pdu_sptr self) -> long"""
        return _blocks_swig5.random_pdu_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(random_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.random_pdu_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(random_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.random_pdu_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(random_pdu_sptr self) -> std::string"""
        return _blocks_swig5.random_pdu_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(random_pdu_sptr self, std::string name)"""
        return _blocks_swig5.random_pdu_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(random_pdu_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.random_pdu_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(random_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(random_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(random_pdu_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_subscribers(self, which_port)

random_pdu_sptr_swigregister = _blocks_swig5.random_pdu_sptr_swigregister
random_pdu_sptr_swigregister(random_pdu_sptr)

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

class regenerate_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::regenerate_bb)> 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::regenerate_bb)> self) -> regenerate_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::regenerate_bb)> self, regenerate_bb p) -> regenerate_bb_sptr
        """
        this = _blocks_swig5.new_regenerate_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(regenerate_bb_sptr self) -> regenerate_bb"""
        return _blocks_swig5.regenerate_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_regenerate_bb_sptr
    __del__ = lambda self: None

    def make(self, period, max_regen=500):
        """make(regenerate_bb_sptr self, int period, unsigned int max_regen=500) -> regenerate_bb_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_make(self, period, max_regen)


    def set_max_regen(self, regen):
        """set_max_regen(regenerate_bb_sptr self, unsigned int regen)"""
        return _blocks_swig5.regenerate_bb_sptr_set_max_regen(self, regen)


    def set_period(self, period):
        """set_period(regenerate_bb_sptr self, int period)"""
        return _blocks_swig5.regenerate_bb_sptr_set_period(self, period)


    def max_regen(self):
        """max_regen(regenerate_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.regenerate_bb_sptr_max_regen(self)


    def period(self):
        """period(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_period(self)


    def history(self):
        """history(regenerate_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.regenerate_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(regenerate_bb_sptr self, int which, int delay)
        declare_sample_delay(regenerate_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.regenerate_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(regenerate_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.regenerate_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(regenerate_bb_sptr self) -> double"""
        return _blocks_swig5.regenerate_bb_sptr_relative_rate(self)


    def start(self):
        """start(regenerate_bb_sptr self) -> bool"""
        return _blocks_swig5.regenerate_bb_sptr_start(self)


    def stop(self):
        """stop(regenerate_bb_sptr self) -> bool"""
        return _blocks_swig5.regenerate_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(regenerate_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.regenerate_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(regenerate_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.regenerate_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(regenerate_bb_sptr self, int m)"""
        return _blocks_swig5.regenerate_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(regenerate_bb_sptr self)"""
        return _blocks_swig5.regenerate_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(regenerate_bb_sptr self) -> bool"""
        return _blocks_swig5.regenerate_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(regenerate_bb_sptr self, int m)"""
        return _blocks_swig5.regenerate_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(regenerate_bb_sptr self, int i) -> long"""
        return _blocks_swig5.regenerate_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(regenerate_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(regenerate_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.regenerate_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(regenerate_bb_sptr self, int i) -> long"""
        return _blocks_swig5.regenerate_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(regenerate_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(regenerate_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.regenerate_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(regenerate_bb_sptr self, int which) -> float
        pc_input_buffers_full(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(regenerate_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(regenerate_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(regenerate_bb_sptr self, int which) -> float
        pc_output_buffers_full(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(regenerate_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(regenerate_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(regenerate_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.regenerate_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(regenerate_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.regenerate_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(regenerate_bb_sptr self)"""
        return _blocks_swig5.regenerate_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(regenerate_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.regenerate_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(regenerate_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(regenerate_bb_sptr self) -> std::string"""
        return _blocks_swig5.regenerate_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(regenerate_bb_sptr self) -> std::string"""
        return _blocks_swig5.regenerate_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(regenerate_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(regenerate_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(regenerate_bb_sptr self) -> long"""
        return _blocks_swig5.regenerate_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(regenerate_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(regenerate_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.regenerate_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(regenerate_bb_sptr self) -> std::string"""
        return _blocks_swig5.regenerate_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(regenerate_bb_sptr self, std::string name)"""
        return _blocks_swig5.regenerate_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(regenerate_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.regenerate_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(regenerate_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(regenerate_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(regenerate_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_subscribers(self, which_port)

regenerate_bb_sptr_swigregister = _blocks_swig5.regenerate_bb_sptr_swigregister
regenerate_bb_sptr_swigregister(regenerate_bb_sptr)

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

class repack_bits_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::repack_bits_bb)> 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::repack_bits_bb)> self) -> repack_bits_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::repack_bits_bb)> self, repack_bits_bb p) -> repack_bits_bb_sptr
        """
        this = _blocks_swig5.new_repack_bits_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(repack_bits_bb_sptr self) -> repack_bits_bb"""
        return _blocks_swig5.repack_bits_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_repack_bits_bb_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(repack_bits_bb_sptr self, int k, int l=8, std::string const & tsb_tag_key, bool align_output=False, gr::endianness_t endianness) -> repack_bits_bb_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_make(self, *args, **kwargs)


    def set_k_and_l(self, k, l):
        """set_k_and_l(repack_bits_bb_sptr self, int k, int l)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_k_and_l(self, k, l)


    def history(self):
        """history(repack_bits_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.repack_bits_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(repack_bits_bb_sptr self, int which, int delay)
        declare_sample_delay(repack_bits_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.repack_bits_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(repack_bits_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.repack_bits_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(repack_bits_bb_sptr self) -> double"""
        return _blocks_swig5.repack_bits_bb_sptr_relative_rate(self)


    def start(self):
        """start(repack_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.repack_bits_bb_sptr_start(self)


    def stop(self):
        """stop(repack_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.repack_bits_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(repack_bits_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.repack_bits_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(repack_bits_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.repack_bits_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(repack_bits_bb_sptr self, int m)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(repack_bits_bb_sptr self)"""
        return _blocks_swig5.repack_bits_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(repack_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.repack_bits_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(repack_bits_bb_sptr self, int m)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(repack_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig5.repack_bits_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(repack_bits_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(repack_bits_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.repack_bits_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(repack_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig5.repack_bits_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(repack_bits_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(repack_bits_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.repack_bits_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(repack_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(repack_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(repack_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(repack_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(repack_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(repack_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(repack_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repack_bits_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(repack_bits_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(repack_bits_bb_sptr self)"""
        return _blocks_swig5.repack_bits_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(repack_bits_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.repack_bits_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(repack_bits_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(repack_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(repack_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(repack_bits_bb_sptr self) -> long"""
        return _blocks_swig5.repack_bits_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(repack_bits_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(repack_bits_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.repack_bits_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(repack_bits_bb_sptr self, std::string name)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(repack_bits_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.repack_bits_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(repack_bits_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(repack_bits_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(repack_bits_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_subscribers(self, which_port)

repack_bits_bb_sptr_swigregister = _blocks_swig5.repack_bits_bb_sptr_swigregister
repack_bits_bb_sptr_swigregister(repack_bits_bb_sptr)

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

class repeat_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::repeat)> 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::repeat)> self) -> repeat_sptr
        __init__(boost::shared_ptr<(gr::blocks::repeat)> self, repeat p) -> repeat_sptr
        """
        this = _blocks_swig5.new_repeat_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(repeat_sptr self) -> repeat"""
        return _blocks_swig5.repeat_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_repeat_sptr
    __del__ = lambda self: None

    def make(self, itemsize, repeat):
        """make(repeat_sptr self, size_t itemsize, int repeat) -> repeat_sptr"""
        return _blocks_swig5.repeat_sptr_make(self, itemsize, repeat)


    def history(self):
        """history(repeat_sptr self) -> unsigned int"""
        return _blocks_swig5.repeat_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(repeat_sptr self, int which, int delay)
        declare_sample_delay(repeat_sptr self, unsigned int delay)
        """
        return _blocks_swig5.repeat_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(repeat_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.repeat_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(repeat_sptr self) -> double"""
        return _blocks_swig5.repeat_sptr_relative_rate(self)


    def start(self):
        """start(repeat_sptr self) -> bool"""
        return _blocks_swig5.repeat_sptr_start(self)


    def stop(self):
        """stop(repeat_sptr self) -> bool"""
        return _blocks_swig5.repeat_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(repeat_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.repeat_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(repeat_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.repeat_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(repeat_sptr self, int m)"""
        return _blocks_swig5.repeat_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(repeat_sptr self)"""
        return _blocks_swig5.repeat_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(repeat_sptr self) -> bool"""
        return _blocks_swig5.repeat_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(repeat_sptr self, int m)"""
        return _blocks_swig5.repeat_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(repeat_sptr self, int i) -> long"""
        return _blocks_swig5.repeat_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(repeat_sptr self, long max_output_buffer)
        set_max_output_buffer(repeat_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.repeat_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(repeat_sptr self, int i) -> long"""
        return _blocks_swig5.repeat_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(repeat_sptr self, long min_output_buffer)
        set_min_output_buffer(repeat_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.repeat_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(repeat_sptr self, int which) -> float
        pc_input_buffers_full(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(repeat_sptr self, int which) -> float
        pc_input_buffers_full_avg(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(repeat_sptr self, int which) -> float
        pc_input_buffers_full_var(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(repeat_sptr self, int which) -> float
        pc_output_buffers_full(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(repeat_sptr self, int which) -> float
        pc_output_buffers_full_avg(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(repeat_sptr self, int which) -> float
        pc_output_buffers_full_var(repeat_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.repeat_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(repeat_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.repeat_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(repeat_sptr self)"""
        return _blocks_swig5.repeat_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(repeat_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.repeat_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(repeat_sptr self, int priority) -> int"""
        return _blocks_swig5.repeat_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(repeat_sptr self) -> std::string"""
        return _blocks_swig5.repeat_sptr_name(self)


    def symbol_name(self):
        """symbol_name(repeat_sptr self) -> std::string"""
        return _blocks_swig5.repeat_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(repeat_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repeat_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(repeat_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repeat_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(repeat_sptr self) -> long"""
        return _blocks_swig5.repeat_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(repeat_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.repeat_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(repeat_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.repeat_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(repeat_sptr self) -> std::string"""
        return _blocks_swig5.repeat_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(repeat_sptr self, std::string name)"""
        return _blocks_swig5.repeat_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(repeat_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.repeat_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(repeat_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.repeat_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(repeat_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.repeat_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(repeat_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.repeat_sptr_message_subscribers(self, which_port)

repeat_sptr_swigregister = _blocks_swig5.repeat_sptr_swigregister
repeat_sptr_swigregister(repeat_sptr)

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

class rms_cf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::rms_cf)> 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::rms_cf)> self) -> rms_cf_sptr
        __init__(boost::shared_ptr<(gr::blocks::rms_cf)> self, rms_cf p) -> rms_cf_sptr
        """
        this = _blocks_swig5.new_rms_cf_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(rms_cf_sptr self) -> rms_cf"""
        return _blocks_swig5.rms_cf_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_rms_cf_sptr
    __del__ = lambda self: None

    def make(self, alpha=0.0001):
        """make(rms_cf_sptr self, double alpha=0.0001) -> rms_cf_sptr"""
        return _blocks_swig5.rms_cf_sptr_make(self, alpha)


    def set_alpha(self, alpha):
        """set_alpha(rms_cf_sptr self, double alpha)"""
        return _blocks_swig5.rms_cf_sptr_set_alpha(self, alpha)


    def history(self):
        """history(rms_cf_sptr self) -> unsigned int"""
        return _blocks_swig5.rms_cf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(rms_cf_sptr self, int which, int delay)
        declare_sample_delay(rms_cf_sptr self, unsigned int delay)
        """
        return _blocks_swig5.rms_cf_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(rms_cf_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rms_cf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(rms_cf_sptr self) -> double"""
        return _blocks_swig5.rms_cf_sptr_relative_rate(self)


    def start(self):
        """start(rms_cf_sptr self) -> bool"""
        return _blocks_swig5.rms_cf_sptr_start(self)


    def stop(self):
        """stop(rms_cf_sptr self) -> bool"""
        return _blocks_swig5.rms_cf_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(rms_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.rms_cf_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(rms_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rms_cf_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(rms_cf_sptr self, int m)"""
        return _blocks_swig5.rms_cf_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(rms_cf_sptr self)"""
        return _blocks_swig5.rms_cf_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(rms_cf_sptr self) -> bool"""
        return _blocks_swig5.rms_cf_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(rms_cf_sptr self, int m)"""
        return _blocks_swig5.rms_cf_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(rms_cf_sptr self, int i) -> long"""
        return _blocks_swig5.rms_cf_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(rms_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(rms_cf_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.rms_cf_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(rms_cf_sptr self, int i) -> long"""
        return _blocks_swig5.rms_cf_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(rms_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(rms_cf_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.rms_cf_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(rms_cf_sptr self, int which) -> float
        pc_input_buffers_full(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(rms_cf_sptr self, int which) -> float
        pc_input_buffers_full_avg(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(rms_cf_sptr self, int which) -> float
        pc_input_buffers_full_var(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(rms_cf_sptr self, int which) -> float
        pc_output_buffers_full(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(rms_cf_sptr self, int which) -> float
        pc_output_buffers_full_avg(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(rms_cf_sptr self, int which) -> float
        pc_output_buffers_full_var(rms_cf_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_cf_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(rms_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.rms_cf_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(rms_cf_sptr self)"""
        return _blocks_swig5.rms_cf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(rms_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.rms_cf_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(rms_cf_sptr self, int priority) -> int"""
        return _blocks_swig5.rms_cf_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(rms_cf_sptr self) -> std::string"""
        return _blocks_swig5.rms_cf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(rms_cf_sptr self) -> std::string"""
        return _blocks_swig5.rms_cf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(rms_cf_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_cf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(rms_cf_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_cf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(rms_cf_sptr self) -> long"""
        return _blocks_swig5.rms_cf_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(rms_cf_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.rms_cf_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(rms_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.rms_cf_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(rms_cf_sptr self) -> std::string"""
        return _blocks_swig5.rms_cf_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(rms_cf_sptr self, std::string name)"""
        return _blocks_swig5.rms_cf_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(rms_cf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.rms_cf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(rms_cf_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(rms_cf_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(rms_cf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_subscribers(self, which_port)

rms_cf_sptr_swigregister = _blocks_swig5.rms_cf_sptr_swigregister
rms_cf_sptr_swigregister(rms_cf_sptr)

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

class rms_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::rms_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::rms_ff)> self) -> rms_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::rms_ff)> self, rms_ff p) -> rms_ff_sptr
        """
        this = _blocks_swig5.new_rms_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(rms_ff_sptr self) -> rms_ff"""
        return _blocks_swig5.rms_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_rms_ff_sptr
    __del__ = lambda self: None

    def make(self, alpha=0.0001):
        """make(rms_ff_sptr self, double alpha=0.0001) -> rms_ff_sptr"""
        return _blocks_swig5.rms_ff_sptr_make(self, alpha)


    def set_alpha(self, alpha):
        """set_alpha(rms_ff_sptr self, double alpha)"""
        return _blocks_swig5.rms_ff_sptr_set_alpha(self, alpha)


    def history(self):
        """history(rms_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.rms_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(rms_ff_sptr self, int which, int delay)
        declare_sample_delay(rms_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig5.rms_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(rms_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rms_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(rms_ff_sptr self) -> double"""
        return _blocks_swig5.rms_ff_sptr_relative_rate(self)


    def start(self):
        """start(rms_ff_sptr self) -> bool"""
        return _blocks_swig5.rms_ff_sptr_start(self)


    def stop(self):
        """stop(rms_ff_sptr self) -> bool"""
        return _blocks_swig5.rms_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(rms_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.rms_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(rms_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rms_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(rms_ff_sptr self, int m)"""
        return _blocks_swig5.rms_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(rms_ff_sptr self)"""
        return _blocks_swig5.rms_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(rms_ff_sptr self) -> bool"""
        return _blocks_swig5.rms_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(rms_ff_sptr self, int m)"""
        return _blocks_swig5.rms_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(rms_ff_sptr self, int i) -> long"""
        return _blocks_swig5.rms_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(rms_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(rms_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.rms_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(rms_ff_sptr self, int i) -> long"""
        return _blocks_swig5.rms_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(rms_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(rms_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.rms_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(rms_ff_sptr self, int which) -> float
        pc_input_buffers_full(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(rms_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(rms_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(rms_ff_sptr self, int which) -> float
        pc_output_buffers_full(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(rms_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(rms_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(rms_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rms_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(rms_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.rms_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(rms_ff_sptr self)"""
        return _blocks_swig5.rms_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(rms_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.rms_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(rms_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.rms_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(rms_ff_sptr self) -> std::string"""
        return _blocks_swig5.rms_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(rms_ff_sptr self) -> std::string"""
        return _blocks_swig5.rms_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(rms_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(rms_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(rms_ff_sptr self) -> long"""
        return _blocks_swig5.rms_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(rms_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.rms_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(rms_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.rms_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(rms_ff_sptr self) -> std::string"""
        return _blocks_swig5.rms_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(rms_ff_sptr self, std::string name)"""
        return _blocks_swig5.rms_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(rms_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.rms_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(rms_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(rms_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(rms_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_subscribers(self, which_port)

rms_ff_sptr_swigregister = _blocks_swig5.rms_ff_sptr_swigregister
rms_ff_sptr_swigregister(rms_ff_sptr)

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

class rotator_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::rotator_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::rotator_cc)> self) -> rotator_cc_sptr
        __init__(boost::shared_ptr<(gr::blocks::rotator_cc)> self, rotator_cc p) -> rotator_cc_sptr
        """
        this = _blocks_swig5.new_rotator_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(rotator_cc_sptr self) -> rotator_cc"""
        return _blocks_swig5.rotator_cc_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_rotator_cc_sptr
    __del__ = lambda self: None

    def make(self, phase_inc=0.0):
        """make(rotator_cc_sptr self, double phase_inc=0.0) -> rotator_cc_sptr"""
        return _blocks_swig5.rotator_cc_sptr_make(self, phase_inc)


    def set_phase_inc(self, phase_inc):
        """set_phase_inc(rotator_cc_sptr self, double phase_inc)"""
        return _blocks_swig5.rotator_cc_sptr_set_phase_inc(self, phase_inc)


    def history(self):
        """history(rotator_cc_sptr self) -> unsigned int"""
        return _blocks_swig5.rotator_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(rotator_cc_sptr self, int which, int delay)
        declare_sample_delay(rotator_cc_sptr self, unsigned int delay)
        """
        return _blocks_swig5.rotator_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(rotator_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rotator_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(rotator_cc_sptr self) -> double"""
        return _blocks_swig5.rotator_cc_sptr_relative_rate(self)


    def start(self):
        """start(rotator_cc_sptr self) -> bool"""
        return _blocks_swig5.rotator_cc_sptr_start(self)


    def stop(self):
        """stop(rotator_cc_sptr self) -> bool"""
        return _blocks_swig5.rotator_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(rotator_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.rotator_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(rotator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rotator_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(rotator_cc_sptr self, int m)"""
        return _blocks_swig5.rotator_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(rotator_cc_sptr self)"""
        return _blocks_swig5.rotator_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(rotator_cc_sptr self) -> bool"""
        return _blocks_swig5.rotator_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(rotator_cc_sptr self, int m)"""
        return _blocks_swig5.rotator_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(rotator_cc_sptr self, int i) -> long"""
        return _blocks_swig5.rotator_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(rotator_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(rotator_cc_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.rotator_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(rotator_cc_sptr self, int i) -> long"""
        return _blocks_swig5.rotator_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(rotator_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(rotator_cc_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.rotator_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(rotator_cc_sptr self, int which) -> float
        pc_input_buffers_full(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(rotator_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(rotator_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(rotator_cc_sptr self, int which) -> float
        pc_output_buffers_full(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(rotator_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(rotator_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(rotator_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.rotator_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(rotator_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.rotator_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(rotator_cc_sptr self)"""
        return _blocks_swig5.rotator_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(rotator_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.rotator_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(rotator_cc_sptr self, int priority) -> int"""
        return _blocks_swig5.rotator_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(rotator_cc_sptr self) -> std::string"""
        return _blocks_swig5.rotator_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(rotator_cc_sptr self) -> std::string"""
        return _blocks_swig5.rotator_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(rotator_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rotator_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(rotator_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rotator_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(rotator_cc_sptr self) -> long"""
        return _blocks_swig5.rotator_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(rotator_cc_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.rotator_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(rotator_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.rotator_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(rotator_cc_sptr self) -> std::string"""
        return _blocks_swig5.rotator_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(rotator_cc_sptr self, std::string name)"""
        return _blocks_swig5.rotator_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(rotator_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.rotator_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(rotator_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(rotator_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(rotator_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_subscribers(self, which_port)

rotator_cc_sptr_swigregister = _blocks_swig5.rotator_cc_sptr_swigregister
rotator_cc_sptr_swigregister(rotator_cc_sptr)

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

class sample_and_hold_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sample_and_hold_bb)> 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::sample_and_hold_bb)> self) -> sample_and_hold_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::sample_and_hold_bb)> self, sample_and_hold_bb p) -> sample_and_hold_bb_sptr
        """
        this = _blocks_swig5.new_sample_and_hold_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sample_and_hold_bb_sptr self) -> sample_and_hold_bb"""
        return _blocks_swig5.sample_and_hold_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_bb_sptr
    __del__ = lambda self: None

    def make(self):
        """make(sample_and_hold_bb_sptr self) -> sample_and_hold_bb_sptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_make(self)


    def history(self):
        """history(sample_and_hold_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sample_and_hold_bb_sptr self, int which, int delay)
        declare_sample_delay(sample_and_hold_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sample_and_hold_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sample_and_hold_bb_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sample_and_hold_bb_sptr self) -> double"""
        return _blocks_swig5.sample_and_hold_bb_sptr_relative_rate(self)


    def start(self):
        """start(sample_and_hold_bb_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_bb_sptr_start(self)


    def stop(self):
        """stop(sample_and_hold_bb_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sample_and_hold_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sample_and_hold_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sample_and_hold_bb_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sample_and_hold_bb_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sample_and_hold_bb_sptr self)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sample_and_hold_bb_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sample_and_hold_bb_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sample_and_hold_bb_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sample_and_hold_bb_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sample_and_hold_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(sample_and_hold_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sample_and_hold_bb_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sample_and_hold_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(sample_and_hold_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sample_and_hold_bb_sptr self, int which) -> float
        pc_input_buffers_full(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sample_and_hold_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sample_and_hold_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sample_and_hold_bb_sptr self, int which) -> float
        pc_output_buffers_full(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sample_and_hold_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sample_and_hold_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(sample_and_hold_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sample_and_hold_bb_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sample_and_hold_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sample_and_hold_bb_sptr self)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sample_and_hold_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sample_and_hold_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sample_and_hold_bb_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sample_and_hold_bb_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sample_and_hold_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sample_and_hold_bb_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sample_and_hold_bb_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sample_and_hold_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sample_and_hold_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sample_and_hold_bb_sptr self) -> long"""
        return _blocks_swig5.sample_and_hold_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sample_and_hold_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sample_and_hold_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sample_and_hold_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sample_and_hold_bb_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sample_and_hold_bb_sptr self, std::string name)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sample_and_hold_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sample_and_hold_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sample_and_hold_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sample_and_hold_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sample_and_hold_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_subscribers(self, which_port)

sample_and_hold_bb_sptr_swigregister = _blocks_swig5.sample_and_hold_bb_sptr_swigregister
sample_and_hold_bb_sptr_swigregister(sample_and_hold_bb_sptr)

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

class sample_and_hold_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sample_and_hold_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::sample_and_hold_ss)> self) -> sample_and_hold_ss_sptr
        __init__(boost::shared_ptr<(gr::blocks::sample_and_hold_ss)> self, sample_and_hold_ss p) -> sample_and_hold_ss_sptr
        """
        this = _blocks_swig5.new_sample_and_hold_ss_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sample_and_hold_ss_sptr self) -> sample_and_hold_ss"""
        return _blocks_swig5.sample_and_hold_ss_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ss_sptr
    __del__ = lambda self: None

    def make(self):
        """make(sample_and_hold_ss_sptr self) -> sample_and_hold_ss_sptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_make(self)


    def history(self):
        """history(sample_and_hold_ss_sptr self) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sample_and_hold_ss_sptr self, int which, int delay)
        declare_sample_delay(sample_and_hold_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sample_and_hold_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sample_and_hold_ss_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sample_and_hold_ss_sptr self) -> double"""
        return _blocks_swig5.sample_and_hold_ss_sptr_relative_rate(self)


    def start(self):
        """start(sample_and_hold_ss_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ss_sptr_start(self)


    def stop(self):
        """stop(sample_and_hold_ss_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ss_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sample_and_hold_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ss_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sample_and_hold_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ss_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sample_and_hold_ss_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sample_and_hold_ss_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sample_and_hold_ss_sptr self)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sample_and_hold_ss_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ss_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sample_and_hold_ss_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sample_and_hold_ss_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sample_and_hold_ss_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ss_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sample_and_hold_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(sample_and_hold_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sample_and_hold_ss_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ss_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sample_and_hold_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(sample_and_hold_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sample_and_hold_ss_sptr self, int which) -> float
        pc_input_buffers_full(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sample_and_hold_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sample_and_hold_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sample_and_hold_ss_sptr self, int which) -> float
        pc_output_buffers_full(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sample_and_hold_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sample_and_hold_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(sample_and_hold_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sample_and_hold_ss_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ss_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sample_and_hold_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sample_and_hold_ss_sptr self)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sample_and_hold_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sample_and_hold_ss_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sample_and_hold_ss_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sample_and_hold_ss_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sample_and_hold_ss_sptr self, int priority) -> int"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sample_and_hold_ss_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ss_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sample_and_hold_ss_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ss_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sample_and_hold_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sample_and_hold_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sample_and_hold_ss_sptr self) -> long"""
        return _blocks_swig5.sample_and_hold_ss_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sample_and_hold_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sample_and_hold_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sample_and_hold_ss_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sample_and_hold_ss_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ss_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sample_and_hold_ss_sptr self, std::string name)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sample_and_hold_ss_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ss_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sample_and_hold_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sample_and_hold_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sample_and_hold_ss_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_subscribers(self, which_port)

sample_and_hold_ss_sptr_swigregister = _blocks_swig5.sample_and_hold_ss_sptr_swigregister
sample_and_hold_ss_sptr_swigregister(sample_and_hold_ss_sptr)

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

class sample_and_hold_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sample_and_hold_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::sample_and_hold_ii)> self) -> sample_and_hold_ii_sptr
        __init__(boost::shared_ptr<(gr::blocks::sample_and_hold_ii)> self, sample_and_hold_ii p) -> sample_and_hold_ii_sptr
        """
        this = _blocks_swig5.new_sample_and_hold_ii_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sample_and_hold_ii_sptr self) -> sample_and_hold_ii"""
        return _blocks_swig5.sample_and_hold_ii_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ii_sptr
    __del__ = lambda self: None

    def make(self):
        """make(sample_and_hold_ii_sptr self) -> sample_and_hold_ii_sptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_make(self)


    def history(self):
        """history(sample_and_hold_ii_sptr self) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sample_and_hold_ii_sptr self, int which, int delay)
        declare_sample_delay(sample_and_hold_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sample_and_hold_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sample_and_hold_ii_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sample_and_hold_ii_sptr self) -> double"""
        return _blocks_swig5.sample_and_hold_ii_sptr_relative_rate(self)


    def start(self):
        """start(sample_and_hold_ii_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ii_sptr_start(self)


    def stop(self):
        """stop(sample_and_hold_ii_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ii_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sample_and_hold_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ii_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sample_and_hold_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ii_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sample_and_hold_ii_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sample_and_hold_ii_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sample_and_hold_ii_sptr self)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sample_and_hold_ii_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ii_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sample_and_hold_ii_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sample_and_hold_ii_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sample_and_hold_ii_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ii_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sample_and_hold_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(sample_and_hold_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sample_and_hold_ii_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ii_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sample_and_hold_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(sample_and_hold_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sample_and_hold_ii_sptr self, int which) -> float
        pc_input_buffers_full(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sample_and_hold_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sample_and_hold_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sample_and_hold_ii_sptr self, int which) -> float
        pc_output_buffers_full(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sample_and_hold_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sample_and_hold_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(sample_and_hold_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sample_and_hold_ii_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ii_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sample_and_hold_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sample_and_hold_ii_sptr self)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sample_and_hold_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sample_and_hold_ii_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sample_and_hold_ii_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sample_and_hold_ii_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sample_and_hold_ii_sptr self, int priority) -> int"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sample_and_hold_ii_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ii_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sample_and_hold_ii_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ii_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sample_and_hold_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sample_and_hold_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sample_and_hold_ii_sptr self) -> long"""
        return _blocks_swig5.sample_and_hold_ii_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sample_and_hold_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sample_and_hold_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sample_and_hold_ii_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sample_and_hold_ii_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ii_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sample_and_hold_ii_sptr self, std::string name)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sample_and_hold_ii_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ii_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sample_and_hold_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sample_and_hold_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sample_and_hold_ii_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_subscribers(self, which_port)

sample_and_hold_ii_sptr_swigregister = _blocks_swig5.sample_and_hold_ii_sptr_swigregister
sample_and_hold_ii_sptr_swigregister(sample_and_hold_ii_sptr)

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

class sample_and_hold_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sample_and_hold_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::sample_and_hold_ff)> self) -> sample_and_hold_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::sample_and_hold_ff)> self, sample_and_hold_ff p) -> sample_and_hold_ff_sptr
        """
        this = _blocks_swig5.new_sample_and_hold_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sample_and_hold_ff_sptr self) -> sample_and_hold_ff"""
        return _blocks_swig5.sample_and_hold_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ff_sptr
    __del__ = lambda self: None

    def make(self):
        """make(sample_and_hold_ff_sptr self) -> sample_and_hold_ff_sptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_make(self)


    def history(self):
        """history(sample_and_hold_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sample_and_hold_ff_sptr self, int which, int delay)
        declare_sample_delay(sample_and_hold_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sample_and_hold_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sample_and_hold_ff_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sample_and_hold_ff_sptr self) -> double"""
        return _blocks_swig5.sample_and_hold_ff_sptr_relative_rate(self)


    def start(self):
        """start(sample_and_hold_ff_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ff_sptr_start(self)


    def stop(self):
        """stop(sample_and_hold_ff_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sample_and_hold_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sample_and_hold_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sample_and_hold_ff_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sample_and_hold_ff_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sample_and_hold_ff_sptr self)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sample_and_hold_ff_sptr self) -> bool"""
        return _blocks_swig5.sample_and_hold_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sample_and_hold_ff_sptr self, int m)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sample_and_hold_ff_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sample_and_hold_ff_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sample_and_hold_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(sample_and_hold_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sample_and_hold_ff_sptr self, int i) -> long"""
        return _blocks_swig5.sample_and_hold_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sample_and_hold_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(sample_and_hold_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sample_and_hold_ff_sptr self, int which) -> float
        pc_input_buffers_full(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sample_and_hold_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sample_and_hold_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sample_and_hold_ff_sptr self, int which) -> float
        pc_output_buffers_full(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sample_and_hold_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sample_and_hold_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(sample_and_hold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sample_and_hold_ff_sptr self) -> float"""
        return _blocks_swig5.sample_and_hold_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sample_and_hold_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sample_and_hold_ff_sptr self)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sample_and_hold_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sample_and_hold_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sample_and_hold_ff_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sample_and_hold_ff_sptr self) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sample_and_hold_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sample_and_hold_ff_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sample_and_hold_ff_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sample_and_hold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sample_and_hold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sample_and_hold_ff_sptr self) -> long"""
        return _blocks_swig5.sample_and_hold_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sample_and_hold_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sample_and_hold_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sample_and_hold_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sample_and_hold_ff_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sample_and_hold_ff_sptr self, std::string name)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sample_and_hold_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sample_and_hold_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sample_and_hold_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sample_and_hold_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_subscribers(self, which_port)

sample_and_hold_ff_sptr_swigregister = _blocks_swig5.sample_and_hold_ff_sptr_swigregister
sample_and_hold_ff_sptr_swigregister(sample_and_hold_ff_sptr)

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

class short_to_char_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::short_to_char)> 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::short_to_char)> self) -> short_to_char_sptr
        __init__(boost::shared_ptr<(gr::blocks::short_to_char)> self, short_to_char p) -> short_to_char_sptr
        """
        this = _blocks_swig5.new_short_to_char_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(short_to_char_sptr self) -> short_to_char"""
        return _blocks_swig5.short_to_char_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_short_to_char_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(short_to_char_sptr self, size_t vlen=1) -> short_to_char_sptr"""
        return _blocks_swig5.short_to_char_sptr_make(self, vlen)


    def history(self):
        """history(short_to_char_sptr self) -> unsigned int"""
        return _blocks_swig5.short_to_char_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(short_to_char_sptr self, int which, int delay)
        declare_sample_delay(short_to_char_sptr self, unsigned int delay)
        """
        return _blocks_swig5.short_to_char_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(short_to_char_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.short_to_char_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(short_to_char_sptr self) -> double"""
        return _blocks_swig5.short_to_char_sptr_relative_rate(self)


    def start(self):
        """start(short_to_char_sptr self) -> bool"""
        return _blocks_swig5.short_to_char_sptr_start(self)


    def stop(self):
        """stop(short_to_char_sptr self) -> bool"""
        return _blocks_swig5.short_to_char_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(short_to_char_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.short_to_char_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(short_to_char_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.short_to_char_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(short_to_char_sptr self, int m)"""
        return _blocks_swig5.short_to_char_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(short_to_char_sptr self)"""
        return _blocks_swig5.short_to_char_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(short_to_char_sptr self) -> bool"""
        return _blocks_swig5.short_to_char_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(short_to_char_sptr self, int m)"""
        return _blocks_swig5.short_to_char_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(short_to_char_sptr self, int i) -> long"""
        return _blocks_swig5.short_to_char_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(short_to_char_sptr self, long max_output_buffer)
        set_max_output_buffer(short_to_char_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.short_to_char_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(short_to_char_sptr self, int i) -> long"""
        return _blocks_swig5.short_to_char_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(short_to_char_sptr self, long min_output_buffer)
        set_min_output_buffer(short_to_char_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.short_to_char_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(short_to_char_sptr self, int which) -> float
        pc_input_buffers_full(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(short_to_char_sptr self, int which) -> float
        pc_input_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(short_to_char_sptr self, int which) -> float
        pc_input_buffers_full_var(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(short_to_char_sptr self, int which) -> float
        pc_output_buffers_full(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(short_to_char_sptr self, int which) -> float
        pc_output_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(short_to_char_sptr self, int which) -> float
        pc_output_buffers_full_var(short_to_char_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_char_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(short_to_char_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.short_to_char_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(short_to_char_sptr self)"""
        return _blocks_swig5.short_to_char_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(short_to_char_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.short_to_char_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(short_to_char_sptr self, int priority) -> int"""
        return _blocks_swig5.short_to_char_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_name(self)


    def symbol_name(self):
        """symbol_name(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(short_to_char_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_char_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(short_to_char_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_char_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(short_to_char_sptr self) -> long"""
        return _blocks_swig5.short_to_char_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(short_to_char_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.short_to_char_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(short_to_char_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.short_to_char_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(short_to_char_sptr self, std::string name)"""
        return _blocks_swig5.short_to_char_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(short_to_char_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.short_to_char_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(short_to_char_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(short_to_char_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(short_to_char_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_subscribers(self, which_port)

short_to_char_sptr_swigregister = _blocks_swig5.short_to_char_sptr_swigregister
short_to_char_sptr_swigregister(short_to_char_sptr)

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

class short_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::short_to_float)> 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::short_to_float)> self) -> short_to_float_sptr
        __init__(boost::shared_ptr<(gr::blocks::short_to_float)> self, short_to_float p) -> short_to_float_sptr
        """
        this = _blocks_swig5.new_short_to_float_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(short_to_float_sptr self) -> short_to_float"""
        return _blocks_swig5.short_to_float_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_short_to_float_sptr
    __del__ = lambda self: None

    def make(self, vlen=1, scale=1.0):
        """make(short_to_float_sptr self, size_t vlen=1, float scale=1.0) -> short_to_float_sptr"""
        return _blocks_swig5.short_to_float_sptr_make(self, vlen, scale)


    def scale(self):
        """scale(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_scale(self)


    def set_scale(self, scale):
        """set_scale(short_to_float_sptr self, float scale)"""
        return _blocks_swig5.short_to_float_sptr_set_scale(self, scale)


    def history(self):
        """history(short_to_float_sptr self) -> unsigned int"""
        return _blocks_swig5.short_to_float_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(short_to_float_sptr self, int which, int delay)
        declare_sample_delay(short_to_float_sptr self, unsigned int delay)
        """
        return _blocks_swig5.short_to_float_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(short_to_float_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.short_to_float_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(short_to_float_sptr self) -> double"""
        return _blocks_swig5.short_to_float_sptr_relative_rate(self)


    def start(self):
        """start(short_to_float_sptr self) -> bool"""
        return _blocks_swig5.short_to_float_sptr_start(self)


    def stop(self):
        """stop(short_to_float_sptr self) -> bool"""
        return _blocks_swig5.short_to_float_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(short_to_float_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.short_to_float_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(short_to_float_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.short_to_float_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(short_to_float_sptr self, int m)"""
        return _blocks_swig5.short_to_float_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(short_to_float_sptr self)"""
        return _blocks_swig5.short_to_float_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(short_to_float_sptr self) -> bool"""
        return _blocks_swig5.short_to_float_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(short_to_float_sptr self, int m)"""
        return _blocks_swig5.short_to_float_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(short_to_float_sptr self, int i) -> long"""
        return _blocks_swig5.short_to_float_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(short_to_float_sptr self, long max_output_buffer)
        set_max_output_buffer(short_to_float_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.short_to_float_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(short_to_float_sptr self, int i) -> long"""
        return _blocks_swig5.short_to_float_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(short_to_float_sptr self, long min_output_buffer)
        set_min_output_buffer(short_to_float_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.short_to_float_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(short_to_float_sptr self, int which) -> float
        pc_input_buffers_full(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(short_to_float_sptr self, int which) -> float
        pc_input_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(short_to_float_sptr self, int which) -> float
        pc_input_buffers_full_var(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(short_to_float_sptr self, int which) -> float
        pc_output_buffers_full(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(short_to_float_sptr self, int which) -> float
        pc_output_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(short_to_float_sptr self, int which) -> float
        pc_output_buffers_full_var(short_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.short_to_float_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(short_to_float_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.short_to_float_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(short_to_float_sptr self)"""
        return _blocks_swig5.short_to_float_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(short_to_float_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.short_to_float_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(short_to_float_sptr self, int priority) -> int"""
        return _blocks_swig5.short_to_float_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_name(self)


    def symbol_name(self):
        """symbol_name(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(short_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_float_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(short_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_float_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(short_to_float_sptr self) -> long"""
        return _blocks_swig5.short_to_float_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(short_to_float_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.short_to_float_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(short_to_float_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.short_to_float_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(short_to_float_sptr self, std::string name)"""
        return _blocks_swig5.short_to_float_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(short_to_float_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.short_to_float_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(short_to_float_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(short_to_float_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(short_to_float_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_subscribers(self, which_port)

short_to_float_sptr_swigregister = _blocks_swig5.short_to_float_sptr_swigregister
short_to_float_sptr_swigregister(short_to_float_sptr)

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

class socket_pdu_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::socket_pdu)> 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::socket_pdu)> self) -> socket_pdu_sptr
        __init__(boost::shared_ptr<(gr::blocks::socket_pdu)> self, socket_pdu p) -> socket_pdu_sptr
        """
        this = _blocks_swig5.new_socket_pdu_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(socket_pdu_sptr self) -> socket_pdu"""
        return _blocks_swig5.socket_pdu_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_socket_pdu_sptr
    __del__ = lambda self: None

    def make(self, type, addr, port, MTU=10000, tcp_no_delay=False):
        """make(socket_pdu_sptr self, std::string type, std::string addr, std::string port, int MTU=10000, bool tcp_no_delay=False) -> socket_pdu_sptr"""
        return _blocks_swig5.socket_pdu_sptr_make(self, type, addr, port, MTU, tcp_no_delay)


    def history(self):
        """history(socket_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.socket_pdu_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(socket_pdu_sptr self, int which, int delay)
        declare_sample_delay(socket_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig5.socket_pdu_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(socket_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.socket_pdu_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(socket_pdu_sptr self) -> double"""
        return _blocks_swig5.socket_pdu_sptr_relative_rate(self)


    def start(self):
        """start(socket_pdu_sptr self) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_start(self)


    def stop(self):
        """stop(socket_pdu_sptr self) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(socket_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.socket_pdu_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(socket_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.socket_pdu_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(socket_pdu_sptr self, int m)"""
        return _blocks_swig5.socket_pdu_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(socket_pdu_sptr self)"""
        return _blocks_swig5.socket_pdu_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(socket_pdu_sptr self) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(socket_pdu_sptr self, int m)"""
        return _blocks_swig5.socket_pdu_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(socket_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.socket_pdu_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(socket_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(socket_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.socket_pdu_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(socket_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.socket_pdu_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(socket_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(socket_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.socket_pdu_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(socket_pdu_sptr self, int which) -> float
        pc_input_buffers_full(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(socket_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(socket_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(socket_pdu_sptr self, int which) -> float
        pc_output_buffers_full(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(socket_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(socket_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(socket_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.socket_pdu_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(socket_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.socket_pdu_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(socket_pdu_sptr self)"""
        return _blocks_swig5.socket_pdu_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(socket_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.socket_pdu_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(socket_pdu_sptr self, int priority) -> int"""
        return _blocks_swig5.socket_pdu_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_name(self)


    def symbol_name(self):
        """symbol_name(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(socket_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.socket_pdu_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(socket_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.socket_pdu_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(socket_pdu_sptr self) -> long"""
        return _blocks_swig5.socket_pdu_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(socket_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.socket_pdu_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(socket_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(socket_pdu_sptr self, std::string name)"""
        return _blocks_swig5.socket_pdu_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(socket_pdu_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.socket_pdu_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(socket_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(socket_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(socket_pdu_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_subscribers(self, which_port)

socket_pdu_sptr_swigregister = _blocks_swig5.socket_pdu_sptr_swigregister
socket_pdu_sptr_swigregister(socket_pdu_sptr)

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

class stretch_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stretch_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::stretch_ff)> self) -> stretch_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::stretch_ff)> self, stretch_ff p) -> stretch_ff_sptr
        """
        this = _blocks_swig5.new_stretch_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(stretch_ff_sptr self) -> stretch_ff"""
        return _blocks_swig5.stretch_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_stretch_ff_sptr
    __del__ = lambda self: None

    def make(self, lo, vlen=1):
        """make(stretch_ff_sptr self, float lo, size_t vlen=1) -> stretch_ff_sptr"""
        return _blocks_swig5.stretch_ff_sptr_make(self, lo, vlen)


    def lo(self):
        """lo(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_lo(self)


    def set_lo(self, lo):
        """set_lo(stretch_ff_sptr self, float lo)"""
        return _blocks_swig5.stretch_ff_sptr_set_lo(self, lo)


    def vlen(self):
        """vlen(stretch_ff_sptr self) -> size_t"""
        return _blocks_swig5.stretch_ff_sptr_vlen(self)


    def history(self):
        """history(stretch_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.stretch_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stretch_ff_sptr self, int which, int delay)
        declare_sample_delay(stretch_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig5.stretch_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stretch_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.stretch_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stretch_ff_sptr self) -> double"""
        return _blocks_swig5.stretch_ff_sptr_relative_rate(self)


    def start(self):
        """start(stretch_ff_sptr self) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_start(self)


    def stop(self):
        """stop(stretch_ff_sptr self) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stretch_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.stretch_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stretch_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.stretch_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stretch_ff_sptr self, int m)"""
        return _blocks_swig5.stretch_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stretch_ff_sptr self)"""
        return _blocks_swig5.stretch_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stretch_ff_sptr self) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stretch_ff_sptr self, int m)"""
        return _blocks_swig5.stretch_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stretch_ff_sptr self, int i) -> long"""
        return _blocks_swig5.stretch_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stretch_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(stretch_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.stretch_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stretch_ff_sptr self, int i) -> long"""
        return _blocks_swig5.stretch_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stretch_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(stretch_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.stretch_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stretch_ff_sptr self, int which) -> float
        pc_input_buffers_full(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stretch_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stretch_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stretch_ff_sptr self, int which) -> float
        pc_output_buffers_full(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stretch_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stretch_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(stretch_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.stretch_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stretch_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.stretch_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stretch_ff_sptr self)"""
        return _blocks_swig5.stretch_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stretch_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.stretch_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stretch_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.stretch_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stretch_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.stretch_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stretch_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.stretch_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stretch_ff_sptr self) -> long"""
        return _blocks_swig5.stretch_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stretch_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.stretch_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stretch_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stretch_ff_sptr self, std::string name)"""
        return _blocks_swig5.stretch_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stretch_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.stretch_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stretch_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stretch_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stretch_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_subscribers(self, which_port)

stretch_ff_sptr_swigregister = _blocks_swig5.stretch_ff_sptr_swigregister
stretch_ff_sptr_swigregister(stretch_ff_sptr)

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

class sub_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sub_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::sub_ff)> self) -> sub_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::sub_ff)> self, sub_ff p) -> sub_ff_sptr
        """
        this = _blocks_swig5.new_sub_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sub_ff_sptr self) -> sub_ff"""
        return _blocks_swig5.sub_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sub_ff_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(sub_ff_sptr self, size_t vlen=1) -> sub_ff_sptr"""
        return _blocks_swig5.sub_ff_sptr_make(self, vlen)


    def history(self):
        """history(sub_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sub_ff_sptr self, int which, int delay)
        declare_sample_delay(sub_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sub_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sub_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sub_ff_sptr self) -> double"""
        return _blocks_swig5.sub_ff_sptr_relative_rate(self)


    def start(self):
        """start(sub_ff_sptr self) -> bool"""
        return _blocks_swig5.sub_ff_sptr_start(self)


    def stop(self):
        """stop(sub_ff_sptr self) -> bool"""
        return _blocks_swig5.sub_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sub_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sub_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sub_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sub_ff_sptr self, int m)"""
        return _blocks_swig5.sub_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sub_ff_sptr self)"""
        return _blocks_swig5.sub_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sub_ff_sptr self) -> bool"""
        return _blocks_swig5.sub_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sub_ff_sptr self, int m)"""
        return _blocks_swig5.sub_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sub_ff_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sub_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(sub_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sub_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sub_ff_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sub_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(sub_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sub_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sub_ff_sptr self, int which) -> float
        pc_input_buffers_full(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sub_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sub_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sub_ff_sptr self, int which) -> float
        pc_output_buffers_full(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sub_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sub_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(sub_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sub_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sub_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sub_ff_sptr self)"""
        return _blocks_swig5.sub_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sub_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sub_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sub_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sub_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sub_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sub_ff_sptr self) -> long"""
        return _blocks_swig5.sub_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sub_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sub_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sub_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sub_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sub_ff_sptr self, std::string name)"""
        return _blocks_swig5.sub_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sub_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sub_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sub_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sub_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sub_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_subscribers(self, which_port)

sub_ff_sptr_swigregister = _blocks_swig5.sub_ff_sptr_swigregister
sub_ff_sptr_swigregister(sub_ff_sptr)

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

class sub_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sub_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::sub_ss)> self) -> sub_ss_sptr
        __init__(boost::shared_ptr<(gr::blocks::sub_ss)> self, sub_ss p) -> sub_ss_sptr
        """
        this = _blocks_swig5.new_sub_ss_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sub_ss_sptr self) -> sub_ss"""
        return _blocks_swig5.sub_ss_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sub_ss_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(sub_ss_sptr self, size_t vlen=1) -> sub_ss_sptr"""
        return _blocks_swig5.sub_ss_sptr_make(self, vlen)


    def history(self):
        """history(sub_ss_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ss_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sub_ss_sptr self, int which, int delay)
        declare_sample_delay(sub_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sub_ss_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sub_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ss_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sub_ss_sptr self) -> double"""
        return _blocks_swig5.sub_ss_sptr_relative_rate(self)


    def start(self):
        """start(sub_ss_sptr self) -> bool"""
        return _blocks_swig5.sub_ss_sptr_start(self)


    def stop(self):
        """stop(sub_ss_sptr self) -> bool"""
        return _blocks_swig5.sub_ss_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sub_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sub_ss_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sub_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ss_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sub_ss_sptr self, int m)"""
        return _blocks_swig5.sub_ss_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sub_ss_sptr self)"""
        return _blocks_swig5.sub_ss_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sub_ss_sptr self) -> bool"""
        return _blocks_swig5.sub_ss_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sub_ss_sptr self, int m)"""
        return _blocks_swig5.sub_ss_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sub_ss_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ss_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sub_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(sub_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sub_ss_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sub_ss_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ss_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sub_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(sub_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sub_ss_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sub_ss_sptr self, int which) -> float
        pc_input_buffers_full(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sub_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sub_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sub_ss_sptr self, int which) -> float
        pc_output_buffers_full(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sub_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sub_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(sub_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ss_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sub_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sub_ss_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sub_ss_sptr self)"""
        return _blocks_swig5.sub_ss_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sub_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sub_ss_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sub_ss_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ss_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sub_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ss_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sub_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ss_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sub_ss_sptr self) -> long"""
        return _blocks_swig5.sub_ss_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sub_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sub_ss_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sub_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sub_ss_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sub_ss_sptr self, std::string name)"""
        return _blocks_swig5.sub_ss_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sub_ss_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sub_ss_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sub_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sub_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sub_ss_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_subscribers(self, which_port)

sub_ss_sptr_swigregister = _blocks_swig5.sub_ss_sptr_swigregister
sub_ss_sptr_swigregister(sub_ss_sptr)

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

class sub_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sub_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::sub_ii)> self) -> sub_ii_sptr
        __init__(boost::shared_ptr<(gr::blocks::sub_ii)> self, sub_ii p) -> sub_ii_sptr
        """
        this = _blocks_swig5.new_sub_ii_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sub_ii_sptr self) -> sub_ii"""
        return _blocks_swig5.sub_ii_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sub_ii_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(sub_ii_sptr self, size_t vlen=1) -> sub_ii_sptr"""
        return _blocks_swig5.sub_ii_sptr_make(self, vlen)


    def history(self):
        """history(sub_ii_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ii_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sub_ii_sptr self, int which, int delay)
        declare_sample_delay(sub_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sub_ii_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sub_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ii_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sub_ii_sptr self) -> double"""
        return _blocks_swig5.sub_ii_sptr_relative_rate(self)


    def start(self):
        """start(sub_ii_sptr self) -> bool"""
        return _blocks_swig5.sub_ii_sptr_start(self)


    def stop(self):
        """stop(sub_ii_sptr self) -> bool"""
        return _blocks_swig5.sub_ii_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sub_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sub_ii_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sub_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ii_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sub_ii_sptr self, int m)"""
        return _blocks_swig5.sub_ii_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sub_ii_sptr self)"""
        return _blocks_swig5.sub_ii_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sub_ii_sptr self) -> bool"""
        return _blocks_swig5.sub_ii_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sub_ii_sptr self, int m)"""
        return _blocks_swig5.sub_ii_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sub_ii_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ii_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sub_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(sub_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sub_ii_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sub_ii_sptr self, int i) -> long"""
        return _blocks_swig5.sub_ii_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sub_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(sub_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sub_ii_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sub_ii_sptr self, int which) -> float
        pc_input_buffers_full(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sub_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sub_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sub_ii_sptr self, int which) -> float
        pc_output_buffers_full(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sub_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sub_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(sub_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_ii_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sub_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sub_ii_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sub_ii_sptr self)"""
        return _blocks_swig5.sub_ii_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sub_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sub_ii_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sub_ii_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ii_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sub_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ii_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sub_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ii_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sub_ii_sptr self) -> long"""
        return _blocks_swig5.sub_ii_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sub_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sub_ii_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sub_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sub_ii_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sub_ii_sptr self, std::string name)"""
        return _blocks_swig5.sub_ii_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sub_ii_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sub_ii_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sub_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sub_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sub_ii_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_subscribers(self, which_port)

sub_ii_sptr_swigregister = _blocks_swig5.sub_ii_sptr_swigregister
sub_ii_sptr_swigregister(sub_ii_sptr)

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

class sub_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::sub_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::sub_cc)> self) -> sub_cc_sptr
        __init__(boost::shared_ptr<(gr::blocks::sub_cc)> self, sub_cc p) -> sub_cc_sptr
        """
        this = _blocks_swig5.new_sub_cc_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sub_cc_sptr self) -> sub_cc"""
        return _blocks_swig5.sub_cc_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_sub_cc_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(sub_cc_sptr self, size_t vlen=1) -> sub_cc_sptr"""
        return _blocks_swig5.sub_cc_sptr_make(self, vlen)


    def history(self):
        """history(sub_cc_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sub_cc_sptr self, int which, int delay)
        declare_sample_delay(sub_cc_sptr self, unsigned int delay)
        """
        return _blocks_swig5.sub_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sub_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sub_cc_sptr self) -> double"""
        return _blocks_swig5.sub_cc_sptr_relative_rate(self)


    def start(self):
        """start(sub_cc_sptr self) -> bool"""
        return _blocks_swig5.sub_cc_sptr_start(self)


    def stop(self):
        """stop(sub_cc_sptr self) -> bool"""
        return _blocks_swig5.sub_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sub_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.sub_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sub_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sub_cc_sptr self, int m)"""
        return _blocks_swig5.sub_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sub_cc_sptr self)"""
        return _blocks_swig5.sub_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sub_cc_sptr self) -> bool"""
        return _blocks_swig5.sub_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sub_cc_sptr self, int m)"""
        return _blocks_swig5.sub_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sub_cc_sptr self, int i) -> long"""
        return _blocks_swig5.sub_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sub_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(sub_cc_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.sub_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sub_cc_sptr self, int i) -> long"""
        return _blocks_swig5.sub_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sub_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(sub_cc_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.sub_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sub_cc_sptr self, int which) -> float
        pc_input_buffers_full(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sub_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sub_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sub_cc_sptr self, int which) -> float
        pc_output_buffers_full(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sub_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sub_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(sub_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.sub_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sub_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.sub_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sub_cc_sptr self)"""
        return _blocks_swig5.sub_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sub_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.sub_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sub_cc_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sub_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sub_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sub_cc_sptr self) -> long"""
        return _blocks_swig5.sub_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sub_cc_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.sub_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sub_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.sub_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sub_cc_sptr self, std::string name)"""
        return _blocks_swig5.sub_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sub_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.sub_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sub_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sub_cc_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sub_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_subscribers(self, which_port)

sub_cc_sptr_swigregister = _blocks_swig5.sub_cc_sptr_swigregister
sub_cc_sptr_swigregister(sub_cc_sptr)

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

class tag_gate_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tag_gate)> 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_gate)> self) -> tag_gate_sptr
        __init__(boost::shared_ptr<(gr::blocks::tag_gate)> self, tag_gate p) -> tag_gate_sptr
        """
        this = _blocks_swig5.new_tag_gate_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tag_gate_sptr self) -> tag_gate"""
        return _blocks_swig5.tag_gate_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tag_gate_sptr
    __del__ = lambda self: None

    def set_propagation(self, propagate_tags):
        """set_propagation(tag_gate_sptr self, bool propagate_tags)"""
        return _blocks_swig5.tag_gate_sptr_set_propagation(self, propagate_tags)


    def make(self, item_size, propagate_tags=False):
        """make(tag_gate_sptr self, size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
        return _blocks_swig5.tag_gate_sptr_make(self, item_size, propagate_tags)


    def history(self):
        """history(tag_gate_sptr self) -> unsigned int"""
        return _blocks_swig5.tag_gate_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tag_gate_sptr self, int which, int delay)
        declare_sample_delay(tag_gate_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tag_gate_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tag_gate_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tag_gate_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tag_gate_sptr self) -> int"""
        return _blocks_swig5.tag_gate_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tag_gate_sptr self) -> double"""
        return _blocks_swig5.tag_gate_sptr_relative_rate(self)


    def start(self):
        """start(tag_gate_sptr self) -> bool"""
        return _blocks_swig5.tag_gate_sptr_start(self)


    def stop(self):
        """stop(tag_gate_sptr self) -> bool"""
        return _blocks_swig5.tag_gate_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tag_gate_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tag_gate_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tag_gate_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tag_gate_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tag_gate_sptr self) -> int"""
        return _blocks_swig5.tag_gate_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tag_gate_sptr self, int m)"""
        return _blocks_swig5.tag_gate_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tag_gate_sptr self)"""
        return _blocks_swig5.tag_gate_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tag_gate_sptr self) -> bool"""
        return _blocks_swig5.tag_gate_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tag_gate_sptr self, int m)"""
        return _blocks_swig5.tag_gate_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tag_gate_sptr self) -> int"""
        return _blocks_swig5.tag_gate_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tag_gate_sptr self, int i) -> long"""
        return _blocks_swig5.tag_gate_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tag_gate_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_gate_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tag_gate_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tag_gate_sptr self, int i) -> long"""
        return _blocks_swig5.tag_gate_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tag_gate_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_gate_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tag_gate_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tag_gate_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig5.tag_gate_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tag_gate_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tag_gate_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tag_gate_sptr self)"""
        return _blocks_swig5.tag_gate_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tag_gate_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tag_gate_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tag_gate_sptr self) -> int"""
        return _blocks_swig5.tag_gate_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tag_gate_sptr self) -> int"""
        return _blocks_swig5.tag_gate_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tag_gate_sptr self, int priority) -> int"""
        return _blocks_swig5.tag_gate_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tag_gate_sptr self) -> std::string"""
        return _blocks_swig5.tag_gate_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tag_gate_sptr self) -> std::string"""
        return _blocks_swig5.tag_gate_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tag_gate_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tag_gate_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tag_gate_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tag_gate_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tag_gate_sptr self) -> long"""
        return _blocks_swig5.tag_gate_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tag_gate_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tag_gate_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tag_gate_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tag_gate_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tag_gate_sptr self) -> std::string"""
        return _blocks_swig5.tag_gate_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tag_gate_sptr self, std::string name)"""
        return _blocks_swig5.tag_gate_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tag_gate_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tag_gate_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tag_gate_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tag_gate_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tag_gate_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tag_gate_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tag_gate_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tag_gate_sptr_message_subscribers(self, which_port)

tag_gate_sptr_swigregister = _blocks_swig5.tag_gate_sptr_swigregister
tag_gate_sptr_swigregister(tag_gate_sptr)

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

class tagged_stream_align_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_stream_align)> 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_stream_align)> self) -> tagged_stream_align_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_stream_align)> self, tagged_stream_align p) -> tagged_stream_align_sptr
        """
        this = _blocks_swig5.new_tagged_stream_align_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_stream_align_sptr self) -> tagged_stream_align"""
        return _blocks_swig5.tagged_stream_align_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_align_sptr
    __del__ = lambda self: None

    def make(self, itemsize, lengthtagname):
        """make(tagged_stream_align_sptr self, size_t itemsize, std::string const & lengthtagname) -> tagged_stream_align_sptr"""
        return _blocks_swig5.tagged_stream_align_sptr_make(self, itemsize, lengthtagname)


    def history(self):
        """history(tagged_stream_align_sptr self) -> unsigned int"""
        return _blocks_swig5.tagged_stream_align_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_stream_align_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_align_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tagged_stream_align_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_stream_align_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tagged_stream_align_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_stream_align_sptr self) -> double"""
        return _blocks_swig5.tagged_stream_align_sptr_relative_rate(self)


    def start(self):
        """start(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_align_sptr_start(self)


    def stop(self):
        """stop(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_align_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_stream_align_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tagged_stream_align_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_stream_align_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tagged_stream_align_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_stream_align_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_align_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_stream_align_sptr self)"""
        return _blocks_swig5.tagged_stream_align_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_align_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_stream_align_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_align_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_stream_align_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_align_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_stream_align_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_align_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tagged_stream_align_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_stream_align_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_align_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_stream_align_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_align_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tagged_stream_align_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_align_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_align_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_stream_align_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tagged_stream_align_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_stream_align_sptr self)"""
        return _blocks_swig5.tagged_stream_align_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_stream_align_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tagged_stream_align_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_stream_align_sptr self, int priority) -> int"""
        return _blocks_swig5.tagged_stream_align_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_align_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_align_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_stream_align_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_align_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_stream_align_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_align_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_stream_align_sptr self) -> long"""
        return _blocks_swig5.tagged_stream_align_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_stream_align_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tagged_stream_align_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_stream_align_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tagged_stream_align_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_align_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_stream_align_sptr self, std::string name)"""
        return _blocks_swig5.tagged_stream_align_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_stream_align_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tagged_stream_align_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_stream_align_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_align_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_stream_align_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_align_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_stream_align_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_align_sptr_message_subscribers(self, which_port)

tagged_stream_align_sptr_swigregister = _blocks_swig5.tagged_stream_align_sptr_swigregister
tagged_stream_align_sptr_swigregister(tagged_stream_align_sptr)

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

class tagged_stream_mux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_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::tagged_stream_mux)> self) -> tagged_stream_mux_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_stream_mux)> self, tagged_stream_mux p) -> tagged_stream_mux_sptr
        """
        this = _blocks_swig5.new_tagged_stream_mux_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_stream_mux_sptr self) -> tagged_stream_mux"""
        return _blocks_swig5.tagged_stream_mux_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_mux_sptr
    __del__ = lambda self: None

    def make(self, itemsize, lengthtagname, tag_preserve_head_pos=0):
        """make(tagged_stream_mux_sptr self, size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) -> tagged_stream_mux_sptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_make(self, itemsize, lengthtagname, tag_preserve_head_pos)


    def history(self):
        """history(tagged_stream_mux_sptr self) -> unsigned int"""
        return _blocks_swig5.tagged_stream_mux_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_stream_mux_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_mux_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tagged_stream_mux_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_stream_mux_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tagged_stream_mux_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_stream_mux_sptr self) -> double"""
        return _blocks_swig5.tagged_stream_mux_sptr_relative_rate(self)


    def start(self):
        """start(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_mux_sptr_start(self)


    def stop(self):
        """stop(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_mux_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_stream_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tagged_stream_mux_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_stream_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tagged_stream_mux_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_stream_mux_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_mux_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_stream_mux_sptr self)"""
        return _blocks_swig5.tagged_stream_mux_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_mux_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_stream_mux_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_mux_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_stream_mux_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_mux_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_stream_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_mux_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tagged_stream_mux_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_stream_mux_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_mux_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_stream_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_mux_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tagged_stream_mux_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_mux_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_mux_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_stream_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tagged_stream_mux_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_stream_mux_sptr self)"""
        return _blocks_swig5.tagged_stream_mux_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_stream_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tagged_stream_mux_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_stream_mux_sptr self, int priority) -> int"""
        return _blocks_swig5.tagged_stream_mux_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_mux_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_mux_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_stream_mux_sptr self) -> long"""
        return _blocks_swig5.tagged_stream_mux_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_stream_mux_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_stream_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tagged_stream_mux_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_mux_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_stream_mux_sptr self, std::string name)"""
        return _blocks_swig5.tagged_stream_mux_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_stream_mux_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tagged_stream_mux_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_stream_mux_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_mux_sptr_message_subscribers(self, which_port)

tagged_stream_mux_sptr_swigregister = _blocks_swig5.tagged_stream_mux_sptr_swigregister
tagged_stream_mux_sptr_swigregister(tagged_stream_mux_sptr)

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

class tagged_stream_multiply_length_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_stream_multiply_length)> 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_stream_multiply_length)> self) -> tagged_stream_multiply_length_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_stream_multiply_length)> self, tagged_stream_multiply_length p) -> tagged_stream_multiply_length_sptr
        """
        this = _blocks_swig5.new_tagged_stream_multiply_length_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_stream_multiply_length_sptr self) -> tagged_stream_multiply_length"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_multiply_length_sptr
    __del__ = lambda self: None

    def set_scalar(self, scalar):
        """set_scalar(tagged_stream_multiply_length_sptr self, double scalar)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_scalar(self, scalar)


    def make(self, itemsize, lengthtagname, scalar):
        """make(tagged_stream_multiply_length_sptr self, size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_make(self, itemsize, lengthtagname, scalar)


    def history(self):
        """history(tagged_stream_multiply_length_sptr self) -> unsigned int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_stream_multiply_length_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_multiply_length_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_stream_multiply_length_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_stream_multiply_length_sptr self) -> double"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_relative_rate(self)


    def start(self):
        """start(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_start(self)


    def stop(self):
        """stop(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_stream_multiply_length_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_stream_multiply_length_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_stream_multiply_length_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_stream_multiply_length_sptr self)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_stream_multiply_length_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_stream_multiply_length_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_stream_multiply_length_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_multiply_length_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_stream_multiply_length_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_stream_multiply_length_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_multiply_length_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_stream_multiply_length_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_stream_multiply_length_sptr self)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_stream_multiply_length_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_stream_multiply_length_sptr self, int priority) -> int"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_stream_multiply_length_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_stream_multiply_length_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_stream_multiply_length_sptr self) -> long"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_stream_multiply_length_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_stream_multiply_length_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_stream_multiply_length_sptr self, std::string name)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_stream_multiply_length_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_stream_multiply_length_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_stream_multiply_length_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_stream_multiply_length_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_multiply_length_sptr_message_subscribers(self, which_port)

tagged_stream_multiply_length_sptr_swigregister = _blocks_swig5.tagged_stream_multiply_length_sptr_swigregister
tagged_stream_multiply_length_sptr_swigregister(tagged_stream_multiply_length_sptr)

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

class tagged_stream_to_pdu_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_stream_to_pdu)> 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_stream_to_pdu)> self) -> tagged_stream_to_pdu_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_stream_to_pdu)> self, tagged_stream_to_pdu p) -> tagged_stream_to_pdu_sptr
        """
        this = _blocks_swig5.new_tagged_stream_to_pdu_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_stream_to_pdu_sptr self) -> tagged_stream_to_pdu"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tagged_stream_to_pdu_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tagged_stream_to_pdu_sptr self, gr::blocks::pdu::vector_type type, std::string const & lengthtagname) -> tagged_stream_to_pdu_sptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tagged_stream_to_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_stream_to_pdu_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_to_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_stream_to_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_stream_to_pdu_sptr self) -> double"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_relative_rate(self)


    def start(self):
        """start(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_start(self)


    def stop(self):
        """stop(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_stream_to_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_stream_to_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_stream_to_pdu_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_stream_to_pdu_sptr self)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_stream_to_pdu_sptr self, int m)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_stream_to_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_stream_to_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_to_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_stream_to_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_stream_to_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_to_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_stream_to_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_stream_to_pdu_sptr self)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_stream_to_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_stream_to_pdu_sptr self, int priority) -> int"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_stream_to_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_stream_to_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_stream_to_pdu_sptr self) -> long"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_stream_to_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_stream_to_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_stream_to_pdu_sptr self, std::string name)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_stream_to_pdu_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_stream_to_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_stream_to_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_stream_to_pdu_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tagged_stream_to_pdu_sptr_message_subscribers(self, which_port)

tagged_stream_to_pdu_sptr_swigregister = _blocks_swig5.tagged_stream_to_pdu_sptr_swigregister
tagged_stream_to_pdu_sptr_swigregister(tagged_stream_to_pdu_sptr)

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

class tags_strobe_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tags_strobe)> 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::tags_strobe)> self) -> tags_strobe_sptr
        __init__(boost::shared_ptr<(gr::blocks::tags_strobe)> self, tags_strobe p) -> tags_strobe_sptr
        """
        this = _blocks_swig5.new_tags_strobe_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tags_strobe_sptr self) -> tags_strobe"""
        return _blocks_swig5.tags_strobe_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tags_strobe_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tags_strobe_sptr self, size_t sizeof_stream_item, swig_int_ptr value, uint64_t nsamps, swig_int_ptr key) -> tags_strobe_sptr"""
        return _blocks_swig5.tags_strobe_sptr_make(self, *args, **kwargs)


    def set_value(self, value):
        """set_value(tags_strobe_sptr self, swig_int_ptr value)"""
        return _blocks_swig5.tags_strobe_sptr_set_value(self, value)


    def set_key(self, key):
        """set_key(tags_strobe_sptr self, swig_int_ptr key)"""
        return _blocks_swig5.tags_strobe_sptr_set_key(self, key)


    def value(self):
        """value(tags_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_sptr_value(self)


    def key(self):
        """key(tags_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_sptr_key(self)


    def set_nsamps(self, nsamps):
        """set_nsamps(tags_strobe_sptr self, uint64_t nsamps)"""
        return _blocks_swig5.tags_strobe_sptr_set_nsamps(self, nsamps)


    def nsamps(self):
        """nsamps(tags_strobe_sptr self) -> uint64_t"""
        return _blocks_swig5.tags_strobe_sptr_nsamps(self)


    def history(self):
        """history(tags_strobe_sptr self) -> unsigned int"""
        return _blocks_swig5.tags_strobe_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tags_strobe_sptr self, int which, int delay)
        declare_sample_delay(tags_strobe_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tags_strobe_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tags_strobe_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tags_strobe_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tags_strobe_sptr self) -> int"""
        return _blocks_swig5.tags_strobe_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tags_strobe_sptr self) -> double"""
        return _blocks_swig5.tags_strobe_sptr_relative_rate(self)


    def start(self):
        """start(tags_strobe_sptr self) -> bool"""
        return _blocks_swig5.tags_strobe_sptr_start(self)


    def stop(self):
        """stop(tags_strobe_sptr self) -> bool"""
        return _blocks_swig5.tags_strobe_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tags_strobe_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tags_strobe_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tags_strobe_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tags_strobe_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tags_strobe_sptr self) -> int"""
        return _blocks_swig5.tags_strobe_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tags_strobe_sptr self, int m)"""
        return _blocks_swig5.tags_strobe_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tags_strobe_sptr self)"""
        return _blocks_swig5.tags_strobe_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tags_strobe_sptr self) -> bool"""
        return _blocks_swig5.tags_strobe_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tags_strobe_sptr self, int m)"""
        return _blocks_swig5.tags_strobe_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tags_strobe_sptr self) -> int"""
        return _blocks_swig5.tags_strobe_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tags_strobe_sptr self, int i) -> long"""
        return _blocks_swig5.tags_strobe_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tags_strobe_sptr self, long max_output_buffer)
        set_max_output_buffer(tags_strobe_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tags_strobe_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tags_strobe_sptr self, int i) -> long"""
        return _blocks_swig5.tags_strobe_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tags_strobe_sptr self, long min_output_buffer)
        set_min_output_buffer(tags_strobe_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tags_strobe_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full_var(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full_var(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tags_strobe_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig5.tags_strobe_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tags_strobe_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tags_strobe_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tags_strobe_sptr self)"""
        return _blocks_swig5.tags_strobe_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tags_strobe_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tags_strobe_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tags_strobe_sptr self) -> int"""
        return _blocks_swig5.tags_strobe_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tags_strobe_sptr self) -> int"""
        return _blocks_swig5.tags_strobe_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tags_strobe_sptr self, int priority) -> int"""
        return _blocks_swig5.tags_strobe_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig5.tags_strobe_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig5.tags_strobe_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tags_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tags_strobe_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tags_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tags_strobe_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tags_strobe_sptr self) -> long"""
        return _blocks_swig5.tags_strobe_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tags_strobe_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tags_strobe_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tags_strobe_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tags_strobe_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig5.tags_strobe_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tags_strobe_sptr self, std::string name)"""
        return _blocks_swig5.tags_strobe_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tags_strobe_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tags_strobe_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tags_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tags_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tags_strobe_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tags_strobe_sptr_message_subscribers(self, which_port)

tags_strobe_sptr_swigregister = _blocks_swig5.tags_strobe_sptr_swigregister
tags_strobe_sptr_swigregister(tags_strobe_sptr)

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

class threshold_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::threshold_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::threshold_ff)> self) -> threshold_ff_sptr
        __init__(boost::shared_ptr<(gr::blocks::threshold_ff)> self, threshold_ff p) -> threshold_ff_sptr
        """
        this = _blocks_swig5.new_threshold_ff_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(threshold_ff_sptr self) -> threshold_ff"""
        return _blocks_swig5.threshold_ff_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_threshold_ff_sptr
    __del__ = lambda self: None

    def make(self, lo, hi, initial_state=0):
        """make(threshold_ff_sptr self, float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
        return _blocks_swig5.threshold_ff_sptr_make(self, lo, hi, initial_state)


    def lo(self):
        """lo(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_lo(self)


    def set_lo(self, lo):
        """set_lo(threshold_ff_sptr self, float lo)"""
        return _blocks_swig5.threshold_ff_sptr_set_lo(self, lo)


    def hi(self):
        """hi(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_hi(self)


    def set_hi(self, hi):
        """set_hi(threshold_ff_sptr self, float hi)"""
        return _blocks_swig5.threshold_ff_sptr_set_hi(self, hi)


    def last_state(self):
        """last_state(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_last_state(self)


    def set_last_state(self, last_state):
        """set_last_state(threshold_ff_sptr self, float last_state)"""
        return _blocks_swig5.threshold_ff_sptr_set_last_state(self, last_state)


    def history(self):
        """history(threshold_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.threshold_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(threshold_ff_sptr self, int which, int delay)
        declare_sample_delay(threshold_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig5.threshold_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(threshold_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.threshold_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(threshold_ff_sptr self) -> int"""
        return _blocks_swig5.threshold_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(threshold_ff_sptr self) -> double"""
        return _blocks_swig5.threshold_ff_sptr_relative_rate(self)


    def start(self):
        """start(threshold_ff_sptr self) -> bool"""
        return _blocks_swig5.threshold_ff_sptr_start(self)


    def stop(self):
        """stop(threshold_ff_sptr self) -> bool"""
        return _blocks_swig5.threshold_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(threshold_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.threshold_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(threshold_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.threshold_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(threshold_ff_sptr self) -> int"""
        return _blocks_swig5.threshold_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(threshold_ff_sptr self, int m)"""
        return _blocks_swig5.threshold_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(threshold_ff_sptr self)"""
        return _blocks_swig5.threshold_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(threshold_ff_sptr self) -> bool"""
        return _blocks_swig5.threshold_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(threshold_ff_sptr self, int m)"""
        return _blocks_swig5.threshold_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(threshold_ff_sptr self) -> int"""
        return _blocks_swig5.threshold_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(threshold_ff_sptr self, int i) -> long"""
        return _blocks_swig5.threshold_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(threshold_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(threshold_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.threshold_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(threshold_ff_sptr self, int i) -> long"""
        return _blocks_swig5.threshold_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(threshold_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(threshold_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.threshold_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.threshold_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig5.threshold_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(threshold_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.threshold_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(threshold_ff_sptr self)"""
        return _blocks_swig5.threshold_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(threshold_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.threshold_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(threshold_ff_sptr self) -> int"""
        return _blocks_swig5.threshold_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(threshold_ff_sptr self) -> int"""
        return _blocks_swig5.threshold_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(threshold_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.threshold_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig5.threshold_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig5.threshold_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(threshold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.threshold_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(threshold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.threshold_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(threshold_ff_sptr self) -> long"""
        return _blocks_swig5.threshold_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(threshold_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.threshold_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(threshold_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.threshold_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig5.threshold_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(threshold_ff_sptr self, std::string name)"""
        return _blocks_swig5.threshold_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(threshold_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.threshold_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(threshold_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.threshold_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(threshold_ff_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.threshold_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(threshold_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.threshold_ff_sptr_message_subscribers(self, which_port)

threshold_ff_sptr_swigregister = _blocks_swig5.threshold_ff_sptr_swigregister
threshold_ff_sptr_swigregister(threshold_ff_sptr)

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

class transcendental_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::transcendental)> 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::transcendental)> self) -> transcendental_sptr
        __init__(boost::shared_ptr<(gr::blocks::transcendental)> self, transcendental p) -> transcendental_sptr
        """
        this = _blocks_swig5.new_transcendental_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(transcendental_sptr self) -> transcendental"""
        return _blocks_swig5.transcendental_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_transcendental_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(transcendental_sptr self, std::string const & name, std::string const & type) -> transcendental_sptr"""
        return _blocks_swig5.transcendental_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(transcendental_sptr self) -> unsigned int"""
        return _blocks_swig5.transcendental_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(transcendental_sptr self, int which, int delay)
        declare_sample_delay(transcendental_sptr self, unsigned int delay)
        """
        return _blocks_swig5.transcendental_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(transcendental_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.transcendental_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(transcendental_sptr self) -> int"""
        return _blocks_swig5.transcendental_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(transcendental_sptr self) -> double"""
        return _blocks_swig5.transcendental_sptr_relative_rate(self)


    def start(self):
        """start(transcendental_sptr self) -> bool"""
        return _blocks_swig5.transcendental_sptr_start(self)


    def stop(self):
        """stop(transcendental_sptr self) -> bool"""
        return _blocks_swig5.transcendental_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(transcendental_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.transcendental_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(transcendental_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.transcendental_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(transcendental_sptr self) -> int"""
        return _blocks_swig5.transcendental_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(transcendental_sptr self, int m)"""
        return _blocks_swig5.transcendental_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(transcendental_sptr self)"""
        return _blocks_swig5.transcendental_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(transcendental_sptr self) -> bool"""
        return _blocks_swig5.transcendental_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(transcendental_sptr self, int m)"""
        return _blocks_swig5.transcendental_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(transcendental_sptr self) -> int"""
        return _blocks_swig5.transcendental_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(transcendental_sptr self, int i) -> long"""
        return _blocks_swig5.transcendental_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(transcendental_sptr self, long max_output_buffer)
        set_max_output_buffer(transcendental_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.transcendental_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(transcendental_sptr self, int i) -> long"""
        return _blocks_swig5.transcendental_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(transcendental_sptr self, long min_output_buffer)
        set_min_output_buffer(transcendental_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.transcendental_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(transcendental_sptr self, int which) -> float
        pc_input_buffers_full(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(transcendental_sptr self, int which) -> float
        pc_input_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(transcendental_sptr self, int which) -> float
        pc_input_buffers_full_var(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(transcendental_sptr self, int which) -> float
        pc_output_buffers_full(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(transcendental_sptr self, int which) -> float
        pc_output_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(transcendental_sptr self, int which) -> float
        pc_output_buffers_full_var(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.transcendental_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(transcendental_sptr self) -> float"""
        return _blocks_swig5.transcendental_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(transcendental_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.transcendental_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(transcendental_sptr self)"""
        return _blocks_swig5.transcendental_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(transcendental_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.transcendental_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(transcendental_sptr self) -> int"""
        return _blocks_swig5.transcendental_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(transcendental_sptr self) -> int"""
        return _blocks_swig5.transcendental_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(transcendental_sptr self, int priority) -> int"""
        return _blocks_swig5.transcendental_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(transcendental_sptr self) -> std::string"""
        return _blocks_swig5.transcendental_sptr_name(self)


    def symbol_name(self):
        """symbol_name(transcendental_sptr self) -> std::string"""
        return _blocks_swig5.transcendental_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(transcendental_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.transcendental_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(transcendental_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.transcendental_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(transcendental_sptr self) -> long"""
        return _blocks_swig5.transcendental_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(transcendental_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.transcendental_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(transcendental_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.transcendental_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(transcendental_sptr self) -> std::string"""
        return _blocks_swig5.transcendental_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(transcendental_sptr self, std::string name)"""
        return _blocks_swig5.transcendental_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(transcendental_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.transcendental_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(transcendental_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.transcendental_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(transcendental_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.transcendental_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(transcendental_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.transcendental_sptr_message_subscribers(self, which_port)

transcendental_sptr_swigregister = _blocks_swig5.transcendental_sptr_swigregister
transcendental_sptr_swigregister(transcendental_sptr)

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

class tuntap_pdu_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tuntap_pdu)> 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::tuntap_pdu)> self) -> tuntap_pdu_sptr
        __init__(boost::shared_ptr<(gr::blocks::tuntap_pdu)> self, tuntap_pdu p) -> tuntap_pdu_sptr
        """
        this = _blocks_swig5.new_tuntap_pdu_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tuntap_pdu_sptr self) -> tuntap_pdu"""
        return _blocks_swig5.tuntap_pdu_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_tuntap_pdu_sptr
    __del__ = lambda self: None

    def make(self, dev, MTU=10000, istunflag=False):
        """make(tuntap_pdu_sptr self, std::string dev, int MTU=10000, bool istunflag=False) -> tuntap_pdu_sptr"""
        return _blocks_swig5.tuntap_pdu_sptr_make(self, dev, MTU, istunflag)


    def history(self):
        """history(tuntap_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.tuntap_pdu_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tuntap_pdu_sptr self, int which, int delay)
        declare_sample_delay(tuntap_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig5.tuntap_pdu_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tuntap_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.tuntap_pdu_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tuntap_pdu_sptr self) -> double"""
        return _blocks_swig5.tuntap_pdu_sptr_relative_rate(self)


    def start(self):
        """start(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig5.tuntap_pdu_sptr_start(self)


    def stop(self):
        """stop(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig5.tuntap_pdu_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tuntap_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.tuntap_pdu_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tuntap_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.tuntap_pdu_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tuntap_pdu_sptr self, int m)"""
        return _blocks_swig5.tuntap_pdu_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tuntap_pdu_sptr self)"""
        return _blocks_swig5.tuntap_pdu_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig5.tuntap_pdu_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tuntap_pdu_sptr self, int m)"""
        return _blocks_swig5.tuntap_pdu_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tuntap_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.tuntap_pdu_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tuntap_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(tuntap_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.tuntap_pdu_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tuntap_pdu_sptr self, int i) -> long"""
        return _blocks_swig5.tuntap_pdu_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tuntap_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(tuntap_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.tuntap_pdu_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.tuntap_pdu_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig5.tuntap_pdu_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tuntap_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.tuntap_pdu_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tuntap_pdu_sptr self)"""
        return _blocks_swig5.tuntap_pdu_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tuntap_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.tuntap_pdu_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tuntap_pdu_sptr self, int priority) -> int"""
        return _blocks_swig5.tuntap_pdu_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tuntap_pdu_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tuntap_pdu_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tuntap_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tuntap_pdu_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tuntap_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.tuntap_pdu_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tuntap_pdu_sptr self) -> long"""
        return _blocks_swig5.tuntap_pdu_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tuntap_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.tuntap_pdu_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tuntap_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.tuntap_pdu_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig5.tuntap_pdu_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tuntap_pdu_sptr self, std::string name)"""
        return _blocks_swig5.tuntap_pdu_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tuntap_pdu_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.tuntap_pdu_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tuntap_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tuntap_pdu_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tuntap_pdu_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.tuntap_pdu_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tuntap_pdu_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.tuntap_pdu_sptr_message_subscribers(self, which_port)

tuntap_pdu_sptr_swigregister = _blocks_swig5.tuntap_pdu_sptr_swigregister
tuntap_pdu_sptr_swigregister(tuntap_pdu_sptr)

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

class uchar_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::uchar_to_float)> 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::uchar_to_float)> self) -> uchar_to_float_sptr
        __init__(boost::shared_ptr<(gr::blocks::uchar_to_float)> self, uchar_to_float p) -> uchar_to_float_sptr
        """
        this = _blocks_swig5.new_uchar_to_float_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(uchar_to_float_sptr self) -> uchar_to_float"""
        return _blocks_swig5.uchar_to_float_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_uchar_to_float_sptr
    __del__ = lambda self: None

    def make(self):
        """make(uchar_to_float_sptr self) -> uchar_to_float_sptr"""
        return _blocks_swig5.uchar_to_float_sptr_make(self)


    def history(self):
        """history(uchar_to_float_sptr self) -> unsigned int"""
        return _blocks_swig5.uchar_to_float_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(uchar_to_float_sptr self, int which, int delay)
        declare_sample_delay(uchar_to_float_sptr self, unsigned int delay)
        """
        return _blocks_swig5.uchar_to_float_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(uchar_to_float_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.uchar_to_float_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(uchar_to_float_sptr self) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(uchar_to_float_sptr self) -> double"""
        return _blocks_swig5.uchar_to_float_sptr_relative_rate(self)


    def start(self):
        """start(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig5.uchar_to_float_sptr_start(self)


    def stop(self):
        """stop(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig5.uchar_to_float_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(uchar_to_float_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.uchar_to_float_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(uchar_to_float_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.uchar_to_float_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(uchar_to_float_sptr self) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(uchar_to_float_sptr self, int m)"""
        return _blocks_swig5.uchar_to_float_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(uchar_to_float_sptr self)"""
        return _blocks_swig5.uchar_to_float_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig5.uchar_to_float_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(uchar_to_float_sptr self, int m)"""
        return _blocks_swig5.uchar_to_float_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(uchar_to_float_sptr self) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(uchar_to_float_sptr self, int i) -> long"""
        return _blocks_swig5.uchar_to_float_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(uchar_to_float_sptr self, long max_output_buffer)
        set_max_output_buffer(uchar_to_float_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.uchar_to_float_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(uchar_to_float_sptr self, int i) -> long"""
        return _blocks_swig5.uchar_to_float_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(uchar_to_float_sptr self, long min_output_buffer)
        set_min_output_buffer(uchar_to_float_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.uchar_to_float_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full_var(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full_var(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.uchar_to_float_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig5.uchar_to_float_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(uchar_to_float_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.uchar_to_float_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(uchar_to_float_sptr self)"""
        return _blocks_swig5.uchar_to_float_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(uchar_to_float_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.uchar_to_float_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(uchar_to_float_sptr self) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(uchar_to_float_sptr self) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(uchar_to_float_sptr self, int priority) -> int"""
        return _blocks_swig5.uchar_to_float_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig5.uchar_to_float_sptr_name(self)


    def symbol_name(self):
        """symbol_name(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig5.uchar_to_float_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(uchar_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.uchar_to_float_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(uchar_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.uchar_to_float_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(uchar_to_float_sptr self) -> long"""
        return _blocks_swig5.uchar_to_float_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(uchar_to_float_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.uchar_to_float_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(uchar_to_float_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.uchar_to_float_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig5.uchar_to_float_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(uchar_to_float_sptr self, std::string name)"""
        return _blocks_swig5.uchar_to_float_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(uchar_to_float_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.uchar_to_float_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(uchar_to_float_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.uchar_to_float_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(uchar_to_float_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.uchar_to_float_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(uchar_to_float_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.uchar_to_float_sptr_message_subscribers(self, which_port)

uchar_to_float_sptr_swigregister = _blocks_swig5.uchar_to_float_sptr_swigregister
uchar_to_float_sptr_swigregister(uchar_to_float_sptr)

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

class udp_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::udp_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::udp_sink)> self) -> udp_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::udp_sink)> self, udp_sink p) -> udp_sink_sptr
        """
        this = _blocks_swig5.new_udp_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(udp_sink_sptr self) -> udp_sink"""
        return _blocks_swig5.udp_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_udp_sink_sptr
    __del__ = lambda self: None

    def make(self, itemsize, host, port, payload_size=1472, eof=True):
        """make(udp_sink_sptr self, size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
        return _blocks_swig5.udp_sink_sptr_make(self, itemsize, host, port, payload_size, eof)


    def payload_size(self):
        """payload_size(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_payload_size(self)


    def connect(self, host, port):
        """connect(udp_sink_sptr self, std::string const & host, int port)"""
        return _blocks_swig5.udp_sink_sptr_connect(self, host, port)


    def disconnect(self):
        """disconnect(udp_sink_sptr self)"""
        return _blocks_swig5.udp_sink_sptr_disconnect(self)


    def history(self):
        """history(udp_sink_sptr self) -> unsigned int"""
        return _blocks_swig5.udp_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(udp_sink_sptr self, int which, int delay)
        declare_sample_delay(udp_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig5.udp_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(udp_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.udp_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(udp_sink_sptr self) -> double"""
        return _blocks_swig5.udp_sink_sptr_relative_rate(self)


    def start(self):
        """start(udp_sink_sptr self) -> bool"""
        return _blocks_swig5.udp_sink_sptr_start(self)


    def stop(self):
        """stop(udp_sink_sptr self) -> bool"""
        return _blocks_swig5.udp_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(udp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.udp_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(udp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.udp_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(udp_sink_sptr self, int m)"""
        return _blocks_swig5.udp_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(udp_sink_sptr self)"""
        return _blocks_swig5.udp_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(udp_sink_sptr self) -> bool"""
        return _blocks_swig5.udp_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(udp_sink_sptr self, int m)"""
        return _blocks_swig5.udp_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(udp_sink_sptr self, int i) -> long"""
        return _blocks_swig5.udp_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(udp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(udp_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.udp_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(udp_sink_sptr self, int i) -> long"""
        return _blocks_swig5.udp_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(udp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(udp_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.udp_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig5.udp_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(udp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.udp_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(udp_sink_sptr self)"""
        return _blocks_swig5.udp_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(udp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.udp_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(udp_sink_sptr self) -> int"""
        return _blocks_swig5.udp_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(udp_sink_sptr self, int priority) -> int"""
        return _blocks_swig5.udp_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(udp_sink_sptr self) -> std::string"""
        return _blocks_swig5.udp_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(udp_sink_sptr self) -> std::string"""
        return _blocks_swig5.udp_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(udp_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.udp_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(udp_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.udp_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(udp_sink_sptr self) -> long"""
        return _blocks_swig5.udp_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(udp_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.udp_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(udp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.udp_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(udp_sink_sptr self) -> std::string"""
        return _blocks_swig5.udp_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(udp_sink_sptr self, std::string name)"""
        return _blocks_swig5.udp_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(udp_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.udp_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(udp_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.udp_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(udp_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.udp_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(udp_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.udp_sink_sptr_message_subscribers(self, which_port)

udp_sink_sptr_swigregister = _blocks_swig5.udp_sink_sptr_swigregister
udp_sink_sptr_swigregister(udp_sink_sptr)

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

class udp_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::udp_source)> 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::udp_source)> self) -> udp_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::udp_source)> self, udp_source p) -> udp_source_sptr
        """
        this = _blocks_swig5.new_udp_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(udp_source_sptr self) -> udp_source"""
        return _blocks_swig5.udp_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_udp_source_sptr
    __del__ = lambda self: None

    def make(self, itemsize, host, port, payload_size=1472, eof=True):
        """make(udp_source_sptr self, size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_source_sptr"""
        return _blocks_swig5.udp_source_sptr_make(self, itemsize, host, port, payload_size, eof)


    def connect(self, host, port):
        """connect(udp_source_sptr self, std::string const & host, int port)"""
        return _blocks_swig5.udp_source_sptr_connect(self, host, port)


    def disconnect(self):
        """disconnect(udp_source_sptr self)"""
        return _blocks_swig5.udp_source_sptr_disconnect(self)


    def payload_size(self):
        """payload_size(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_payload_size(self)


    def get_port(self):
        """get_port(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_get_port(self)


    def history(self):
        """history(udp_source_sptr self) -> unsigned int"""
        return _blocks_swig5.udp_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(udp_source_sptr self, int which, int delay)
        declare_sample_delay(udp_source_sptr self, unsigned int delay)
        """
        return _blocks_swig5.udp_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(udp_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.udp_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(udp_source_sptr self) -> double"""
        return _blocks_swig5.udp_source_sptr_relative_rate(self)


    def start(self):
        """start(udp_source_sptr self) -> bool"""
        return _blocks_swig5.udp_source_sptr_start(self)


    def stop(self):
        """stop(udp_source_sptr self) -> bool"""
        return _blocks_swig5.udp_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(udp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.udp_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(udp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.udp_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(udp_source_sptr self, int m)"""
        return _blocks_swig5.udp_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(udp_source_sptr self)"""
        return _blocks_swig5.udp_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(udp_source_sptr self) -> bool"""
        return _blocks_swig5.udp_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(udp_source_sptr self, int m)"""
        return _blocks_swig5.udp_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(udp_source_sptr self, int i) -> long"""
        return _blocks_swig5.udp_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(udp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(udp_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.udp_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(udp_source_sptr self, int i) -> long"""
        return _blocks_swig5.udp_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(udp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(udp_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.udp_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(udp_source_sptr self, int which) -> float
        pc_input_buffers_full(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(udp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(udp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(udp_source_sptr self, int which) -> float
        pc_output_buffers_full(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(udp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(udp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.udp_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(udp_source_sptr self) -> float"""
        return _blocks_swig5.udp_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(udp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.udp_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(udp_source_sptr self)"""
        return _blocks_swig5.udp_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(udp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.udp_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(udp_source_sptr self) -> int"""
        return _blocks_swig5.udp_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(udp_source_sptr self, int priority) -> int"""
        return _blocks_swig5.udp_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(udp_source_sptr self) -> std::string"""
        return _blocks_swig5.udp_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(udp_source_sptr self) -> std::string"""
        return _blocks_swig5.udp_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(udp_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.udp_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(udp_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.udp_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(udp_source_sptr self) -> long"""
        return _blocks_swig5.udp_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(udp_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.udp_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(udp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.udp_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(udp_source_sptr self) -> std::string"""
        return _blocks_swig5.udp_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(udp_source_sptr self, std::string name)"""
        return _blocks_swig5.udp_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(udp_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.udp_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(udp_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.udp_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(udp_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.udp_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(udp_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.udp_source_sptr_message_subscribers(self, which_port)

udp_source_sptr_swigregister = _blocks_swig5.udp_source_sptr_swigregister
udp_source_sptr_swigregister(udp_source_sptr)

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

class unpack_k_bits_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::unpack_k_bits_bb)> 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::unpack_k_bits_bb)> self) -> unpack_k_bits_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::unpack_k_bits_bb)> self, unpack_k_bits_bb p) -> unpack_k_bits_bb_sptr
        """
        this = _blocks_swig5.new_unpack_k_bits_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(unpack_k_bits_bb_sptr self) -> unpack_k_bits_bb"""
        return _blocks_swig5.unpack_k_bits_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_unpack_k_bits_bb_sptr
    __del__ = lambda self: None

    def make(self, k):
        """make(unpack_k_bits_bb_sptr self, unsigned int k) -> unpack_k_bits_bb_sptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_make(self, k)


    def history(self):
        """history(unpack_k_bits_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(unpack_k_bits_bb_sptr self, int which, int delay)
        declare_sample_delay(unpack_k_bits_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(unpack_k_bits_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(unpack_k_bits_bb_sptr self) -> double"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_relative_rate(self)


    def start(self):
        """start(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_start(self)


    def stop(self):
        """stop(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(unpack_k_bits_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(unpack_k_bits_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(unpack_k_bits_bb_sptr self, int m)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(unpack_k_bits_bb_sptr self)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(unpack_k_bits_bb_sptr self, int m)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(unpack_k_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(unpack_k_bits_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(unpack_k_bits_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(unpack_k_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(unpack_k_bits_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(unpack_k_bits_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(unpack_k_bits_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(unpack_k_bits_bb_sptr self)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(unpack_k_bits_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(unpack_k_bits_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(unpack_k_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(unpack_k_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(unpack_k_bits_bb_sptr self) -> long"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(unpack_k_bits_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(unpack_k_bits_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(unpack_k_bits_bb_sptr self, std::string name)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(unpack_k_bits_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.unpack_k_bits_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(unpack_k_bits_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(unpack_k_bits_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(unpack_k_bits_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.unpack_k_bits_bb_sptr_message_subscribers(self, which_port)

unpack_k_bits_bb_sptr_swigregister = _blocks_swig5.unpack_k_bits_bb_sptr_swigregister
unpack_k_bits_bb_sptr_swigregister(unpack_k_bits_bb_sptr)

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

class unpacked_to_packed_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::unpacked_to_packed_bb)> 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::unpacked_to_packed_bb)> self) -> unpacked_to_packed_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::unpacked_to_packed_bb)> self, unpacked_to_packed_bb p) -> unpacked_to_packed_bb_sptr
        """
        this = _blocks_swig5.new_unpacked_to_packed_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(unpacked_to_packed_bb_sptr self) -> unpacked_to_packed_bb"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_bb_sptr
    __del__ = lambda self: None

    def make(self, bits_per_chunk, endianness):
        """make(unpacked_to_packed_bb_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_make(self, bits_per_chunk, endianness)


    def history(self):
        """history(unpacked_to_packed_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(unpacked_to_packed_bb_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(unpacked_to_packed_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(unpacked_to_packed_bb_sptr self) -> double"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_relative_rate(self)


    def start(self):
        """start(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_start(self)


    def stop(self):
        """stop(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(unpacked_to_packed_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(unpacked_to_packed_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(unpacked_to_packed_bb_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(unpacked_to_packed_bb_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(unpacked_to_packed_bb_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(unpacked_to_packed_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(unpacked_to_packed_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(unpacked_to_packed_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(unpacked_to_packed_bb_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(unpacked_to_packed_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(unpacked_to_packed_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(unpacked_to_packed_bb_sptr self) -> long"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(unpacked_to_packed_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(unpacked_to_packed_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(unpacked_to_packed_bb_sptr self, std::string name)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(unpacked_to_packed_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(unpacked_to_packed_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(unpacked_to_packed_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(unpacked_to_packed_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_bb_sptr_message_subscribers(self, which_port)

unpacked_to_packed_bb_sptr_swigregister = _blocks_swig5.unpacked_to_packed_bb_sptr_swigregister
unpacked_to_packed_bb_sptr_swigregister(unpacked_to_packed_bb_sptr)

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

class unpacked_to_packed_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::unpacked_to_packed_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::unpacked_to_packed_ss)> self) -> unpacked_to_packed_ss_sptr
        __init__(boost::shared_ptr<(gr::blocks::unpacked_to_packed_ss)> self, unpacked_to_packed_ss p) -> unpacked_to_packed_ss_sptr
        """
        this = _blocks_swig5.new_unpacked_to_packed_ss_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(unpacked_to_packed_ss_sptr self) -> unpacked_to_packed_ss"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_ss_sptr
    __del__ = lambda self: None

    def make(self, bits_per_chunk, endianness):
        """make(unpacked_to_packed_ss_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_make(self, bits_per_chunk, endianness)


    def history(self):
        """history(unpacked_to_packed_ss_sptr self) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(unpacked_to_packed_ss_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(unpacked_to_packed_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(unpacked_to_packed_ss_sptr self) -> double"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_relative_rate(self)


    def start(self):
        """start(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_start(self)


    def stop(self):
        """stop(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(unpacked_to_packed_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(unpacked_to_packed_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(unpacked_to_packed_ss_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(unpacked_to_packed_ss_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(unpacked_to_packed_ss_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(unpacked_to_packed_ss_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(unpacked_to_packed_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(unpacked_to_packed_ss_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(unpacked_to_packed_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(unpacked_to_packed_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(unpacked_to_packed_ss_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(unpacked_to_packed_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(unpacked_to_packed_ss_sptr self, int priority) -> int"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_name(self)


    def symbol_name(self):
        """symbol_name(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(unpacked_to_packed_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(unpacked_to_packed_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(unpacked_to_packed_ss_sptr self) -> long"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(unpacked_to_packed_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(unpacked_to_packed_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(unpacked_to_packed_ss_sptr self, std::string name)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(unpacked_to_packed_ss_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(unpacked_to_packed_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(unpacked_to_packed_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(unpacked_to_packed_ss_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ss_sptr_message_subscribers(self, which_port)

unpacked_to_packed_ss_sptr_swigregister = _blocks_swig5.unpacked_to_packed_ss_sptr_swigregister
unpacked_to_packed_ss_sptr_swigregister(unpacked_to_packed_ss_sptr)

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

class unpacked_to_packed_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::unpacked_to_packed_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::unpacked_to_packed_ii)> self) -> unpacked_to_packed_ii_sptr
        __init__(boost::shared_ptr<(gr::blocks::unpacked_to_packed_ii)> self, unpacked_to_packed_ii p) -> unpacked_to_packed_ii_sptr
        """
        this = _blocks_swig5.new_unpacked_to_packed_ii_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(unpacked_to_packed_ii_sptr self) -> unpacked_to_packed_ii"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_unpacked_to_packed_ii_sptr
    __del__ = lambda self: None

    def make(self, bits_per_chunk, endianness):
        """make(unpacked_to_packed_ii_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_make(self, bits_per_chunk, endianness)


    def history(self):
        """history(unpacked_to_packed_ii_sptr self) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(unpacked_to_packed_ii_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(unpacked_to_packed_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(unpacked_to_packed_ii_sptr self) -> double"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_relative_rate(self)


    def start(self):
        """start(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_start(self)


    def stop(self):
        """stop(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(unpacked_to_packed_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(unpacked_to_packed_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(unpacked_to_packed_ii_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(unpacked_to_packed_ii_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(unpacked_to_packed_ii_sptr self, int m)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(unpacked_to_packed_ii_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(unpacked_to_packed_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(unpacked_to_packed_ii_sptr self, int i) -> long"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(unpacked_to_packed_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(unpacked_to_packed_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(unpacked_to_packed_ii_sptr self)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(unpacked_to_packed_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(unpacked_to_packed_ii_sptr self, int priority) -> int"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_name(self)


    def symbol_name(self):
        """symbol_name(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(unpacked_to_packed_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(unpacked_to_packed_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(unpacked_to_packed_ii_sptr self) -> long"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(unpacked_to_packed_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(unpacked_to_packed_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(unpacked_to_packed_ii_sptr self, std::string name)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(unpacked_to_packed_ii_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(unpacked_to_packed_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(unpacked_to_packed_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(unpacked_to_packed_ii_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.unpacked_to_packed_ii_sptr_message_subscribers(self, which_port)

unpacked_to_packed_ii_sptr_swigregister = _blocks_swig5.unpacked_to_packed_ii_sptr_swigregister
unpacked_to_packed_ii_sptr_swigregister(unpacked_to_packed_ii_sptr)

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

class vco_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vco_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::vco_f)> self) -> vco_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::vco_f)> self, vco_f p) -> vco_f_sptr
        """
        this = _blocks_swig5.new_vco_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vco_f_sptr self) -> vco_f"""
        return _blocks_swig5.vco_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_vco_f_sptr
    __del__ = lambda self: None

    def make(self, sampling_rate, sensitivity, amplitude):
        """make(vco_f_sptr self, double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
        return _blocks_swig5.vco_f_sptr_make(self, sampling_rate, sensitivity, amplitude)


    def history(self):
        """history(vco_f_sptr self) -> unsigned int"""
        return _blocks_swig5.vco_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vco_f_sptr self, int which, int delay)
        declare_sample_delay(vco_f_sptr self, unsigned int delay)
        """
        return _blocks_swig5.vco_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vco_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.vco_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vco_f_sptr self) -> int"""
        return _blocks_swig5.vco_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vco_f_sptr self) -> double"""
        return _blocks_swig5.vco_f_sptr_relative_rate(self)


    def start(self):
        """start(vco_f_sptr self) -> bool"""
        return _blocks_swig5.vco_f_sptr_start(self)


    def stop(self):
        """stop(vco_f_sptr self) -> bool"""
        return _blocks_swig5.vco_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vco_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.vco_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vco_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.vco_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vco_f_sptr self) -> int"""
        return _blocks_swig5.vco_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vco_f_sptr self, int m)"""
        return _blocks_swig5.vco_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vco_f_sptr self)"""
        return _blocks_swig5.vco_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vco_f_sptr self) -> bool"""
        return _blocks_swig5.vco_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vco_f_sptr self, int m)"""
        return _blocks_swig5.vco_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vco_f_sptr self) -> int"""
        return _blocks_swig5.vco_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vco_f_sptr self, int i) -> long"""
        return _blocks_swig5.vco_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vco_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vco_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.vco_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vco_f_sptr self, int i) -> long"""
        return _blocks_swig5.vco_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vco_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vco_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.vco_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vco_f_sptr self, int which) -> float
        pc_input_buffers_full(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vco_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vco_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vco_f_sptr self, int which) -> float
        pc_output_buffers_full(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vco_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vco_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vco_f_sptr self) -> float"""
        return _blocks_swig5.vco_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vco_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.vco_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vco_f_sptr self)"""
        return _blocks_swig5.vco_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vco_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.vco_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vco_f_sptr self) -> int"""
        return _blocks_swig5.vco_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vco_f_sptr self) -> int"""
        return _blocks_swig5.vco_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vco_f_sptr self, int priority) -> int"""
        return _blocks_swig5.vco_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vco_f_sptr self) -> std::string"""
        return _blocks_swig5.vco_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vco_f_sptr self) -> std::string"""
        return _blocks_swig5.vco_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vco_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.vco_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vco_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.vco_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vco_f_sptr self) -> long"""
        return _blocks_swig5.vco_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vco_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.vco_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vco_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.vco_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vco_f_sptr self) -> std::string"""
        return _blocks_swig5.vco_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vco_f_sptr self, std::string name)"""
        return _blocks_swig5.vco_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vco_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.vco_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vco_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.vco_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vco_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.vco_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vco_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.vco_f_sptr_message_subscribers(self, which_port)

vco_f_sptr_swigregister = _blocks_swig5.vco_f_sptr_swigregister
vco_f_sptr_swigregister(vco_f_sptr)

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

class vco_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vco_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::vco_c)> self) -> vco_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::vco_c)> self, vco_c p) -> vco_c_sptr
        """
        this = _blocks_swig5.new_vco_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vco_c_sptr self) -> vco_c"""
        return _blocks_swig5.vco_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_vco_c_sptr
    __del__ = lambda self: None

    def make(self, sampling_rate, sensitivity, amplitude):
        """make(vco_c_sptr self, double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
        return _blocks_swig5.vco_c_sptr_make(self, sampling_rate, sensitivity, amplitude)


    def history(self):
        """history(vco_c_sptr self) -> unsigned int"""
        return _blocks_swig5.vco_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vco_c_sptr self, int which, int delay)
        declare_sample_delay(vco_c_sptr self, unsigned int delay)
        """
        return _blocks_swig5.vco_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vco_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.vco_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vco_c_sptr self) -> int"""
        return _blocks_swig5.vco_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vco_c_sptr self) -> double"""
        return _blocks_swig5.vco_c_sptr_relative_rate(self)


    def start(self):
        """start(vco_c_sptr self) -> bool"""
        return _blocks_swig5.vco_c_sptr_start(self)


    def stop(self):
        """stop(vco_c_sptr self) -> bool"""
        return _blocks_swig5.vco_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vco_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.vco_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vco_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.vco_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vco_c_sptr self) -> int"""
        return _blocks_swig5.vco_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vco_c_sptr self, int m)"""
        return _blocks_swig5.vco_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vco_c_sptr self)"""
        return _blocks_swig5.vco_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vco_c_sptr self) -> bool"""
        return _blocks_swig5.vco_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vco_c_sptr self, int m)"""
        return _blocks_swig5.vco_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vco_c_sptr self) -> int"""
        return _blocks_swig5.vco_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vco_c_sptr self, int i) -> long"""
        return _blocks_swig5.vco_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vco_c_sptr self, long max_output_buffer)
        set_max_output_buffer(vco_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.vco_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vco_c_sptr self, int i) -> long"""
        return _blocks_swig5.vco_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vco_c_sptr self, long min_output_buffer)
        set_min_output_buffer(vco_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.vco_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vco_c_sptr self, int which) -> float
        pc_input_buffers_full(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vco_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vco_c_sptr self, int which) -> float
        pc_input_buffers_full_var(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vco_c_sptr self, int which) -> float
        pc_output_buffers_full(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vco_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vco_c_sptr self, int which) -> float
        pc_output_buffers_full_var(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.vco_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vco_c_sptr self) -> float"""
        return _blocks_swig5.vco_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vco_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.vco_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vco_c_sptr self)"""
        return _blocks_swig5.vco_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vco_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.vco_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vco_c_sptr self) -> int"""
        return _blocks_swig5.vco_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vco_c_sptr self) -> int"""
        return _blocks_swig5.vco_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vco_c_sptr self, int priority) -> int"""
        return _blocks_swig5.vco_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vco_c_sptr self) -> std::string"""
        return _blocks_swig5.vco_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vco_c_sptr self) -> std::string"""
        return _blocks_swig5.vco_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vco_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.vco_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vco_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.vco_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vco_c_sptr self) -> long"""
        return _blocks_swig5.vco_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vco_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.vco_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vco_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.vco_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vco_c_sptr self) -> std::string"""
        return _blocks_swig5.vco_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vco_c_sptr self, std::string name)"""
        return _blocks_swig5.vco_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vco_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.vco_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vco_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.vco_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vco_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.vco_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vco_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.vco_c_sptr_message_subscribers(self, which_port)

vco_c_sptr_swigregister = _blocks_swig5.vco_c_sptr_swigregister
vco_c_sptr_swigregister(vco_c_sptr)

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

class xor_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::xor_bb)> 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::xor_bb)> self) -> xor_bb_sptr
        __init__(boost::shared_ptr<(gr::blocks::xor_bb)> self, xor_bb p) -> xor_bb_sptr
        """
        this = _blocks_swig5.new_xor_bb_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(xor_bb_sptr self) -> xor_bb"""
        return _blocks_swig5.xor_bb_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_xor_bb_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(xor_bb_sptr self, size_t vlen=1) -> xor_bb_sptr"""
        return _blocks_swig5.xor_bb_sptr_make(self, vlen)


    def history(self):
        """history(xor_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.xor_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(xor_bb_sptr self, int which, int delay)
        declare_sample_delay(xor_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig5.xor_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(xor_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.xor_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(xor_bb_sptr self) -> int"""
        return _blocks_swig5.xor_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(xor_bb_sptr self) -> double"""
        return _blocks_swig5.xor_bb_sptr_relative_rate(self)


    def start(self):
        """start(xor_bb_sptr self) -> bool"""
        return _blocks_swig5.xor_bb_sptr_start(self)


    def stop(self):
        """stop(xor_bb_sptr self) -> bool"""
        return _blocks_swig5.xor_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(xor_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.xor_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(xor_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.xor_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(xor_bb_sptr self) -> int"""
        return _blocks_swig5.xor_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(xor_bb_sptr self, int m)"""
        return _blocks_swig5.xor_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(xor_bb_sptr self)"""
        return _blocks_swig5.xor_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(xor_bb_sptr self) -> bool"""
        return _blocks_swig5.xor_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(xor_bb_sptr self, int m)"""
        return _blocks_swig5.xor_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(xor_bb_sptr self) -> int"""
        return _blocks_swig5.xor_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(xor_bb_sptr self, int i) -> long"""
        return _blocks_swig5.xor_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(xor_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.xor_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(xor_bb_sptr self, int i) -> long"""
        return _blocks_swig5.xor_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(xor_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.xor_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig5.xor_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(xor_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.xor_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(xor_bb_sptr self)"""
        return _blocks_swig5.xor_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(xor_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.xor_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(xor_bb_sptr self) -> int"""
        return _blocks_swig5.xor_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(xor_bb_sptr self) -> int"""
        return _blocks_swig5.xor_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(xor_bb_sptr self, int priority) -> int"""
        return _blocks_swig5.xor_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(xor_bb_sptr self) -> std::string"""
        return _blocks_swig5.xor_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(xor_bb_sptr self) -> std::string"""
        return _blocks_swig5.xor_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(xor_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(xor_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(xor_bb_sptr self) -> long"""
        return _blocks_swig5.xor_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(xor_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.xor_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(xor_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.xor_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(xor_bb_sptr self) -> std::string"""
        return _blocks_swig5.xor_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(xor_bb_sptr self, std::string name)"""
        return _blocks_swig5.xor_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(xor_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.xor_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(xor_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(xor_bb_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(xor_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.xor_bb_sptr_message_subscribers(self, which_port)

xor_bb_sptr_swigregister = _blocks_swig5.xor_bb_sptr_swigregister
xor_bb_sptr_swigregister(xor_bb_sptr)

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

class xor_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::xor_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::xor_ss)> self) -> xor_ss_sptr
        __init__(boost::shared_ptr<(gr::blocks::xor_ss)> self, xor_ss p) -> xor_ss_sptr
        """
        this = _blocks_swig5.new_xor_ss_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(xor_ss_sptr self) -> xor_ss"""
        return _blocks_swig5.xor_ss_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_xor_ss_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(xor_ss_sptr self, size_t vlen=1) -> xor_ss_sptr"""
        return _blocks_swig5.xor_ss_sptr_make(self, vlen)


    def history(self):
        """history(xor_ss_sptr self) -> unsigned int"""
        return _blocks_swig5.xor_ss_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(xor_ss_sptr self, int which, int delay)
        declare_sample_delay(xor_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig5.xor_ss_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(xor_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.xor_ss_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(xor_ss_sptr self) -> int"""
        return _blocks_swig5.xor_ss_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(xor_ss_sptr self) -> double"""
        return _blocks_swig5.xor_ss_sptr_relative_rate(self)


    def start(self):
        """start(xor_ss_sptr self) -> bool"""
        return _blocks_swig5.xor_ss_sptr_start(self)


    def stop(self):
        """stop(xor_ss_sptr self) -> bool"""
        return _blocks_swig5.xor_ss_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(xor_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.xor_ss_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(xor_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.xor_ss_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(xor_ss_sptr self) -> int"""
        return _blocks_swig5.xor_ss_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(xor_ss_sptr self, int m)"""
        return _blocks_swig5.xor_ss_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(xor_ss_sptr self)"""
        return _blocks_swig5.xor_ss_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(xor_ss_sptr self) -> bool"""
        return _blocks_swig5.xor_ss_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(xor_ss_sptr self, int m)"""
        return _blocks_swig5.xor_ss_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(xor_ss_sptr self) -> int"""
        return _blocks_swig5.xor_ss_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(xor_ss_sptr self, int i) -> long"""
        return _blocks_swig5.xor_ss_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(xor_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.xor_ss_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(xor_ss_sptr self, int i) -> long"""
        return _blocks_swig5.xor_ss_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(xor_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.xor_ss_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ss_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig5.xor_ss_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(xor_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.xor_ss_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(xor_ss_sptr self)"""
        return _blocks_swig5.xor_ss_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(xor_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.xor_ss_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(xor_ss_sptr self) -> int"""
        return _blocks_swig5.xor_ss_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(xor_ss_sptr self) -> int"""
        return _blocks_swig5.xor_ss_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(xor_ss_sptr self, int priority) -> int"""
        return _blocks_swig5.xor_ss_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(xor_ss_sptr self) -> std::string"""
        return _blocks_swig5.xor_ss_sptr_name(self)


    def symbol_name(self):
        """symbol_name(xor_ss_sptr self) -> std::string"""
        return _blocks_swig5.xor_ss_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(xor_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_ss_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(xor_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_ss_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(xor_ss_sptr self) -> long"""
        return _blocks_swig5.xor_ss_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(xor_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.xor_ss_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(xor_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.xor_ss_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(xor_ss_sptr self) -> std::string"""
        return _blocks_swig5.xor_ss_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(xor_ss_sptr self, std::string name)"""
        return _blocks_swig5.xor_ss_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(xor_ss_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.xor_ss_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(xor_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_ss_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(xor_ss_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_ss_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(xor_ss_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.xor_ss_sptr_message_subscribers(self, which_port)

xor_ss_sptr_swigregister = _blocks_swig5.xor_ss_sptr_swigregister
xor_ss_sptr_swigregister(xor_ss_sptr)

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

class xor_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::xor_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::xor_ii)> self) -> xor_ii_sptr
        __init__(boost::shared_ptr<(gr::blocks::xor_ii)> self, xor_ii p) -> xor_ii_sptr
        """
        this = _blocks_swig5.new_xor_ii_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(xor_ii_sptr self) -> xor_ii"""
        return _blocks_swig5.xor_ii_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig5.delete_xor_ii_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(xor_ii_sptr self, size_t vlen=1) -> xor_ii_sptr"""
        return _blocks_swig5.xor_ii_sptr_make(self, vlen)


    def history(self):
        """history(xor_ii_sptr self) -> unsigned int"""
        return _blocks_swig5.xor_ii_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(xor_ii_sptr self, int which, int delay)
        declare_sample_delay(xor_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig5.xor_ii_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(xor_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.xor_ii_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(xor_ii_sptr self) -> int"""
        return _blocks_swig5.xor_ii_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(xor_ii_sptr self) -> double"""
        return _blocks_swig5.xor_ii_sptr_relative_rate(self)


    def start(self):
        """start(xor_ii_sptr self) -> bool"""
        return _blocks_swig5.xor_ii_sptr_start(self)


    def stop(self):
        """stop(xor_ii_sptr self) -> bool"""
        return _blocks_swig5.xor_ii_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(xor_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig5.xor_ii_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(xor_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.xor_ii_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(xor_ii_sptr self) -> int"""
        return _blocks_swig5.xor_ii_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(xor_ii_sptr self, int m)"""
        return _blocks_swig5.xor_ii_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(xor_ii_sptr self)"""
        return _blocks_swig5.xor_ii_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(xor_ii_sptr self) -> bool"""
        return _blocks_swig5.xor_ii_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(xor_ii_sptr self, int m)"""
        return _blocks_swig5.xor_ii_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(xor_ii_sptr self) -> int"""
        return _blocks_swig5.xor_ii_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(xor_ii_sptr self, int i) -> long"""
        return _blocks_swig5.xor_ii_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(xor_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig5.xor_ii_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(xor_ii_sptr self, int i) -> long"""
        return _blocks_swig5.xor_ii_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(xor_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig5.xor_ii_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig5.xor_ii_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig5.xor_ii_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(xor_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig5.xor_ii_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(xor_ii_sptr self)"""
        return _blocks_swig5.xor_ii_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(xor_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig5.xor_ii_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(xor_ii_sptr self) -> int"""
        return _blocks_swig5.xor_ii_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(xor_ii_sptr self) -> int"""
        return _blocks_swig5.xor_ii_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(xor_ii_sptr self, int priority) -> int"""
        return _blocks_swig5.xor_ii_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(xor_ii_sptr self) -> std::string"""
        return _blocks_swig5.xor_ii_sptr_name(self)


    def symbol_name(self):
        """symbol_name(xor_ii_sptr self) -> std::string"""
        return _blocks_swig5.xor_ii_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(xor_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_ii_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(xor_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.xor_ii_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(xor_ii_sptr self) -> long"""
        return _blocks_swig5.xor_ii_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(xor_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig5.xor_ii_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(xor_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig5.xor_ii_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(xor_ii_sptr self) -> std::string"""
        return _blocks_swig5.xor_ii_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(xor_ii_sptr self, std::string name)"""
        return _blocks_swig5.xor_ii_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(xor_ii_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig5.xor_ii_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(xor_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_ii_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(xor_ii_sptr self) -> swig_int_ptr"""
        return _blocks_swig5.xor_ii_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(xor_ii_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig5.xor_ii_sptr_message_subscribers(self, which_port)

xor_ii_sptr_swigregister = _blocks_swig5.xor_ii_sptr_swigregister
xor_ii_sptr_swigregister(xor_ii_sptr)

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



