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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _blocks_swig5
else:
    import _blocks_swig5

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



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

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

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

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

float_t = _blocks_swig5.float_t

complex_t = _blocks_swig5.complex_t


def pdu_port_id() -> "pmt::pmt_t const":
    r"""pdu_port_id() -> swig_pmt_ptr"""
    return _blocks_swig5.pdu_port_id()

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

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

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

def type_from_pmt(vector: "swig_pmt_ptr") -> "gr::blocks::pdu::vector_type":
    r"""type_from_pmt(swig_pmt_ptr vector) -> gr::blocks::pdu::vector_type"""
    return _blocks_swig5.type_from_pmt(vector)
class random_pdu(object):
    r"""Proxy of C++ gr::blocks::random_pdu class."""

    thisown = 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

    @staticmethod
    def make(mintime: "int", maxtime: "int", byte_mask: "unsigned char"=0xFF, length_modulo: "int"=1) -> "gr::blocks::random_pdu::sptr":
        r"""make(int mintime, int maxtime, unsigned char byte_mask=0xFF, int length_modulo=1) -> random_pdu_sptr"""
        return _blocks_swig5.random_pdu_make(mintime, maxtime, byte_mask, length_modulo)
    __swig_destroy__ = _blocks_swig5.delete_random_pdu

# Register random_pdu in _blocks_swig5:
_blocks_swig5.random_pdu_swigregister(random_pdu)

def random_pdu_make(mintime: "int", maxtime: "int", byte_mask: "unsigned char"=0xFF, length_modulo: "int"=1) -> "gr::blocks::random_pdu::sptr":
    r"""random_pdu_make(int mintime, int maxtime, unsigned 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):
    r"""Proxy of C++ gr::blocks::regenerate_bb class."""

    thisown = 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

    @staticmethod
    def make(period: "int", max_regen: "unsigned int"=500) -> "gr::blocks::regenerate_bb::sptr":
        r"""make(int period, unsigned int max_regen=500) -> regenerate_bb_sptr"""
        return _blocks_swig5.regenerate_bb_make(period, max_regen)

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

    def set_period(self, period: "int") -> "void":
        r"""set_period(regenerate_bb self, int period)"""
        return _blocks_swig5.regenerate_bb_set_period(self, period)

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

    def period(self) -> "int":
        r"""period(regenerate_bb self) -> int"""
        return _blocks_swig5.regenerate_bb_period(self)
    __swig_destroy__ = _blocks_swig5.delete_regenerate_bb

# Register regenerate_bb in _blocks_swig5:
_blocks_swig5.regenerate_bb_swigregister(regenerate_bb)

def regenerate_bb_make(period: "int", max_regen: "unsigned int"=500) -> "gr::blocks::regenerate_bb::sptr":
    r"""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):
    r"""Proxy of C++ gr::blocks::repack_bits_bb class."""

    thisown = 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

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

    def set_k_and_l(self, k: "int", l: "int") -> "void":
        r"""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

# Register repack_bits_bb in _blocks_swig5:
_blocks_swig5.repack_bits_bb_swigregister(repack_bits_bb)

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

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

    thisown = 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

    @staticmethod
    def make(itemsize: "size_t", repeat: "int") -> "gr::blocks::repeat::sptr":
        r"""make(size_t itemsize, int repeat) -> repeat_sptr"""
        return _blocks_swig5.repeat_make(itemsize, repeat)

    def interpolation(self) -> "int":
        r"""interpolation(repeat self) -> int"""
        return _blocks_swig5.repeat_interpolation(self)

    def set_interpolation(self, interp: "int") -> "void":
        r"""set_interpolation(repeat self, int interp)"""
        return _blocks_swig5.repeat_set_interpolation(self, interp)
    __swig_destroy__ = _blocks_swig5.delete_repeat

# Register repeat in _blocks_swig5:
_blocks_swig5.repeat_swigregister(repeat)

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

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

    thisown = 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

    @staticmethod
    def make(alpha: "double"=0.0001) -> "gr::blocks::rms_cf::sptr":
        r"""make(double alpha=0.0001) -> rms_cf_sptr"""
        return _blocks_swig5.rms_cf_make(alpha)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(rms_cf self, double alpha)"""
        return _blocks_swig5.rms_cf_set_alpha(self, alpha)
    __swig_destroy__ = _blocks_swig5.delete_rms_cf

# Register rms_cf in _blocks_swig5:
_blocks_swig5.rms_cf_swigregister(rms_cf)

def rms_cf_make(alpha: "double"=0.0001) -> "gr::blocks::rms_cf::sptr":
    r"""rms_cf_make(double alpha=0.0001) -> rms_cf_sptr"""
    return _blocks_swig5.rms_cf_make(alpha)

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

    thisown = 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

    @staticmethod
    def make(alpha: "double"=0.0001) -> "gr::blocks::rms_ff::sptr":
        r"""make(double alpha=0.0001) -> rms_ff_sptr"""
        return _blocks_swig5.rms_ff_make(alpha)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(rms_ff self, double alpha)"""
        return _blocks_swig5.rms_ff_set_alpha(self, alpha)
    __swig_destroy__ = _blocks_swig5.delete_rms_ff

# Register rms_ff in _blocks_swig5:
_blocks_swig5.rms_ff_swigregister(rms_ff)

def rms_ff_make(alpha: "double"=0.0001) -> "gr::blocks::rms_ff::sptr":
    r"""rms_ff_make(double alpha=0.0001) -> rms_ff_sptr"""
    return _blocks_swig5.rms_ff_make(alpha)

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

    thisown = 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

    @staticmethod
    def make(phase_inc: "double"=0.0) -> "gr::blocks::rotator_cc::sptr":
        r"""make(double phase_inc=0.0) -> rotator_cc_sptr"""
        return _blocks_swig5.rotator_cc_make(phase_inc)

    def set_phase_inc(self, phase_inc: "double") -> "void":
        r"""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

# Register rotator_cc in _blocks_swig5:
_blocks_swig5.rotator_cc_swigregister(rotator_cc)

def rotator_cc_make(phase_inc: "double"=0.0) -> "gr::blocks::rotator_cc::sptr":
    r"""rotator_cc_make(double phase_inc=0.0) -> rotator_cc_sptr"""
    return _blocks_swig5.rotator_cc_make(phase_inc)

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

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::blocks::short_to_char::sptr":
        r"""make(size_t vlen=1) -> short_to_char_sptr"""
        return _blocks_swig5.short_to_char_make(vlen)
    __swig_destroy__ = _blocks_swig5.delete_short_to_char

# Register short_to_char in _blocks_swig5:
_blocks_swig5.short_to_char_swigregister(short_to_char)

def short_to_char_make(vlen: "size_t"=1) -> "gr::blocks::short_to_char::sptr":
    r"""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):
    r"""Proxy of C++ gr::blocks::short_to_float class."""

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1, scale: "float"=1.0) -> "gr::blocks::short_to_float::sptr":
        r"""make(size_t vlen=1, float scale=1.0) -> short_to_float_sptr"""
        return _blocks_swig5.short_to_float_make(vlen, scale)

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

    def set_scale(self, scale: "float") -> "void":
        r"""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

# Register short_to_float in _blocks_swig5:
_blocks_swig5.short_to_float_swigregister(short_to_float)

def short_to_float_make(vlen: "size_t"=1, scale: "float"=1.0) -> "gr::blocks::short_to_float::sptr":
    r"""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):
    r"""Proxy of C++ gr::blocks::socket_pdu class."""

    thisown = 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

    @staticmethod
    def make(type: "std::string", addr: "std::string", port: "std::string", MTU: "int"=10000, tcp_no_delay: "bool"=False) -> "gr::blocks::socket_pdu::sptr":
        r"""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)
    __swig_destroy__ = _blocks_swig5.delete_socket_pdu

# Register socket_pdu in _blocks_swig5:
_blocks_swig5.socket_pdu_swigregister(socket_pdu)

def socket_pdu_make(type: "std::string", addr: "std::string", port: "std::string", MTU: "int"=10000, tcp_no_delay: "bool"=False) -> "gr::blocks::socket_pdu::sptr":
    r"""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):
    r"""Proxy of C++ gr::blocks::stretch_ff class."""

    thisown = 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

    @staticmethod
    def make(lo: "float", vlen: "size_t"=1) -> "gr::blocks::stretch_ff::sptr":
        r"""make(float lo, size_t vlen=1) -> stretch_ff_sptr"""
        return _blocks_swig5.stretch_ff_make(lo, vlen)

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

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(stretch_ff self, float lo)"""
        return _blocks_swig5.stretch_ff_set_lo(self, lo)

    def vlen(self) -> "size_t":
        r"""vlen(stretch_ff self) -> size_t"""
        return _blocks_swig5.stretch_ff_vlen(self)
    __swig_destroy__ = _blocks_swig5.delete_stretch_ff

# Register stretch_ff in _blocks_swig5:
_blocks_swig5.stretch_ff_swigregister(stretch_ff)

def stretch_ff_make(lo: "float", vlen: "size_t"=1) -> "gr::blocks::stretch_ff::sptr":
    r"""stretch_ff_make(float lo, size_t vlen=1) -> stretch_ff_sptr"""
    return _blocks_swig5.stretch_ff_make(lo, vlen)

class random_pdu_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::random_pdu > class."""

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

    def __init__(self, *args):
        r"""
        __init__(random_pdu_sptr self) -> random_pdu_sptr
        __init__(random_pdu_sptr self, random_pdu p) -> random_pdu_sptr
        """
        _blocks_swig5.random_pdu_sptr_swiginit(self, _blocks_swig5.new_random_pdu_sptr(*args))

    def __deref__(self) -> "gr::blocks::random_pdu *":
        r"""__deref__(random_pdu_sptr self) -> random_pdu"""
        return _blocks_swig5.random_pdu_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_random_pdu_sptr

    def make(self, mintime: "int", maxtime: "int", byte_mask: "unsigned char"=0xFF, length_modulo: "int"=1) -> "gr::blocks::random_pdu::sptr":
        r"""make(random_pdu_sptr self, int mintime, int maxtime, unsigned 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) -> "unsigned int":
        r"""history(random_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.random_pdu_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(random_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.random_pdu_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(random_pdu_sptr self, int multiple)"""
        return _blocks_swig5.random_pdu_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(random_pdu_sptr self) -> uint64_t"""
        return _blocks_swig5.random_pdu_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(random_pdu_sptr self) -> uint64_t"""
        return _blocks_swig5.random_pdu_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(random_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.random_pdu_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(random_pdu_sptr self, std::string level)"""
        return _blocks_swig5.random_pdu_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(random_pdu_sptr self) -> std::string"""
        return _blocks_swig5.random_pdu_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(random_pdu_sptr self) -> float"""
        return _blocks_swig5.random_pdu_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(random_pdu_sptr self)"""
        return _blocks_swig5.random_pdu_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(random_pdu_sptr self) -> int"""
        return _blocks_swig5.random_pdu_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(random_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.random_pdu_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(random_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.random_pdu_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(random_pdu_sptr self) -> std::string"""
        return _blocks_swig5.random_pdu_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(random_pdu_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.random_pdu_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(random_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(random_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(random_pdu_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.random_pdu_sptr_message_subscribers(self, which_port)

# Register random_pdu_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::regenerate_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(regenerate_bb_sptr self) -> regenerate_bb_sptr
        __init__(regenerate_bb_sptr self, regenerate_bb p) -> regenerate_bb_sptr
        """
        _blocks_swig5.regenerate_bb_sptr_swiginit(self, _blocks_swig5.new_regenerate_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::regenerate_bb *":
        r"""__deref__(regenerate_bb_sptr self) -> regenerate_bb"""
        return _blocks_swig5.regenerate_bb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_regenerate_bb_sptr

    def make(self, period: "int", max_regen: "unsigned int"=500) -> "gr::blocks::regenerate_bb::sptr":
        r"""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: "unsigned int") -> "void":
        r"""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: "int") -> "void":
        r"""set_period(regenerate_bb_sptr self, int period)"""
        return _blocks_swig5.regenerate_bb_sptr_set_period(self, period)

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

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

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(regenerate_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.regenerate_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(regenerate_bb_sptr self, int multiple)"""
        return _blocks_swig5.regenerate_bb_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(regenerate_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.regenerate_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(regenerate_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.regenerate_bb_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(regenerate_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.regenerate_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(regenerate_bb_sptr self, std::string level)"""
        return _blocks_swig5.regenerate_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(regenerate_bb_sptr self) -> std::string"""
        return _blocks_swig5.regenerate_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(regenerate_bb_sptr self) -> float"""
        return _blocks_swig5.regenerate_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(regenerate_bb_sptr self)"""
        return _blocks_swig5.regenerate_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(regenerate_bb_sptr self) -> int"""
        return _blocks_swig5.regenerate_bb_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(regenerate_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(regenerate_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.regenerate_bb_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(regenerate_bb_sptr self) -> std::string"""
        return _blocks_swig5.regenerate_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(regenerate_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.regenerate_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(regenerate_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(regenerate_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(regenerate_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.regenerate_bb_sptr_message_subscribers(self, which_port)

# Register regenerate_bb_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::repack_bits_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(repack_bits_bb_sptr self) -> repack_bits_bb_sptr
        __init__(repack_bits_bb_sptr self, repack_bits_bb p) -> repack_bits_bb_sptr
        """
        _blocks_swig5.repack_bits_bb_sptr_swiginit(self, _blocks_swig5.new_repack_bits_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::repack_bits_bb *":
        r"""__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

    def make(self, *args, **kwargs) -> "gr::blocks::repack_bits_bb::sptr":
        r"""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=GR_LSB_FIRST) -> repack_bits_bb_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_make(self, *args, **kwargs)

    def set_k_and_l(self, k: "int", l: "int") -> "void":
        r"""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) -> "unsigned int":
        r"""history(repack_bits_bb_sptr self) -> unsigned int"""
        return _blocks_swig5.repack_bits_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(repack_bits_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.repack_bits_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(repack_bits_bb_sptr self, int multiple)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(repack_bits_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.repack_bits_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(repack_bits_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.repack_bits_bb_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(repack_bits_bb_sptr self, std::string level)"""
        return _blocks_swig5.repack_bits_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(repack_bits_bb_sptr self) -> float"""
        return _blocks_swig5.repack_bits_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(repack_bits_bb_sptr self)"""
        return _blocks_swig5.repack_bits_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(repack_bits_bb_sptr self) -> int"""
        return _blocks_swig5.repack_bits_bb_sptr_active_thread_priority(self)

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

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_name(self)

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(repack_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(repack_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repack_bits_bb_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(repack_bits_bb_sptr self) -> std::string"""
        return _blocks_swig5.repack_bits_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(repack_bits_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.repack_bits_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(repack_bits_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(repack_bits_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(repack_bits_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.repack_bits_bb_sptr_message_subscribers(self, which_port)

# Register repack_bits_bb_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::repeat > class."""

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

    def __init__(self, *args):
        r"""
        __init__(repeat_sptr self) -> repeat_sptr
        __init__(repeat_sptr self, repeat p) -> repeat_sptr
        """
        _blocks_swig5.repeat_sptr_swiginit(self, _blocks_swig5.new_repeat_sptr(*args))

    def __deref__(self) -> "gr::blocks::repeat *":
        r"""__deref__(repeat_sptr self) -> repeat"""
        return _blocks_swig5.repeat_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_repeat_sptr

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

    def interpolation(self) -> "int":
        r"""interpolation(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_interpolation(self)

    def set_interpolation(self, interp: "int") -> "void":
        r"""set_interpolation(repeat_sptr self, int interp)"""
        return _blocks_swig5.repeat_sptr_set_interpolation(self, interp)

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(repeat_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.repeat_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(repeat_sptr self, int multiple)"""
        return _blocks_swig5.repeat_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(repeat_sptr self) -> uint64_t"""
        return _blocks_swig5.repeat_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(repeat_sptr self) -> uint64_t"""
        return _blocks_swig5.repeat_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(repeat_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.repeat_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(repeat_sptr self, std::string level)"""
        return _blocks_swig5.repeat_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(repeat_sptr self) -> std::string"""
        return _blocks_swig5.repeat_sptr_log_level(self)

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

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""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) -> "void":
        r"""unset_max_noutput_items(repeat_sptr self)"""
        return _blocks_swig5.repeat_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(repeat_sptr self) -> int"""
        return _blocks_swig5.repeat_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_noutput_items(self)

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

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

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

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

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

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(repeat_sptr self) -> float"""
        return _blocks_swig5.repeat_sptr_pc_work_time(self)

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

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

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

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

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(repeat_sptr self)"""
        return _blocks_swig5.repeat_sptr_unset_processor_affinity(self)

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

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

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(repeat_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repeat_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(repeat_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.repeat_sptr_output_signature(self)

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

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

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

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

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

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(repeat_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.repeat_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(repeat_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.repeat_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(repeat_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.repeat_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(repeat_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.repeat_sptr_message_subscribers(self, which_port)

# Register repeat_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::rms_cf > class."""

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

    def __init__(self, *args):
        r"""
        __init__(rms_cf_sptr self) -> rms_cf_sptr
        __init__(rms_cf_sptr self, rms_cf p) -> rms_cf_sptr
        """
        _blocks_swig5.rms_cf_sptr_swiginit(self, _blocks_swig5.new_rms_cf_sptr(*args))

    def __deref__(self) -> "gr::blocks::rms_cf *":
        r"""__deref__(rms_cf_sptr self) -> rms_cf"""
        return _blocks_swig5.rms_cf_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_rms_cf_sptr

    def make(self, alpha: "double"=0.0001) -> "gr::blocks::rms_cf::sptr":
        r"""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: "double") -> "void":
        r"""set_alpha(rms_cf_sptr self, double alpha)"""
        return _blocks_swig5.rms_cf_sptr_set_alpha(self, alpha)

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(rms_cf_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rms_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(rms_cf_sptr self, int multiple)"""
        return _blocks_swig5.rms_cf_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(rms_cf_sptr self) -> uint64_t"""
        return _blocks_swig5.rms_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(rms_cf_sptr self) -> uint64_t"""
        return _blocks_swig5.rms_cf_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(rms_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rms_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(rms_cf_sptr self, std::string level)"""
        return _blocks_swig5.rms_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(rms_cf_sptr self) -> std::string"""
        return _blocks_swig5.rms_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(rms_cf_sptr self) -> float"""
        return _blocks_swig5.rms_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(rms_cf_sptr self)"""
        return _blocks_swig5.rms_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(rms_cf_sptr self) -> int"""
        return _blocks_swig5.rms_cf_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(rms_cf_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(rms_cf_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_cf_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(rms_cf_sptr self) -> std::string"""
        return _blocks_swig5.rms_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(rms_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.rms_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(rms_cf_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(rms_cf_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(rms_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_cf_sptr_message_subscribers(self, which_port)

# Register rms_cf_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::rms_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(rms_ff_sptr self) -> rms_ff_sptr
        __init__(rms_ff_sptr self, rms_ff p) -> rms_ff_sptr
        """
        _blocks_swig5.rms_ff_sptr_swiginit(self, _blocks_swig5.new_rms_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::rms_ff *":
        r"""__deref__(rms_ff_sptr self) -> rms_ff"""
        return _blocks_swig5.rms_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_rms_ff_sptr

    def make(self, alpha: "double"=0.0001) -> "gr::blocks::rms_ff::sptr":
        r"""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: "double") -> "void":
        r"""set_alpha(rms_ff_sptr self, double alpha)"""
        return _blocks_swig5.rms_ff_sptr_set_alpha(self, alpha)

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(rms_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rms_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(rms_ff_sptr self, int multiple)"""
        return _blocks_swig5.rms_ff_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(rms_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.rms_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(rms_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.rms_ff_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(rms_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rms_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(rms_ff_sptr self, std::string level)"""
        return _blocks_swig5.rms_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(rms_ff_sptr self) -> std::string"""
        return _blocks_swig5.rms_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(rms_ff_sptr self) -> float"""
        return _blocks_swig5.rms_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(rms_ff_sptr self)"""
        return _blocks_swig5.rms_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(rms_ff_sptr self) -> int"""
        return _blocks_swig5.rms_ff_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(rms_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(rms_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rms_ff_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(rms_ff_sptr self) -> std::string"""
        return _blocks_swig5.rms_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(rms_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.rms_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(rms_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(rms_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(rms_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.rms_ff_sptr_message_subscribers(self, which_port)

# Register rms_ff_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::rotator_cc > class."""

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

    def __init__(self, *args):
        r"""
        __init__(rotator_cc_sptr self) -> rotator_cc_sptr
        __init__(rotator_cc_sptr self, rotator_cc p) -> rotator_cc_sptr
        """
        _blocks_swig5.rotator_cc_sptr_swiginit(self, _blocks_swig5.new_rotator_cc_sptr(*args))

    def __deref__(self) -> "gr::blocks::rotator_cc *":
        r"""__deref__(rotator_cc_sptr self) -> rotator_cc"""
        return _blocks_swig5.rotator_cc_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_rotator_cc_sptr

    def make(self, phase_inc: "double"=0.0) -> "gr::blocks::rotator_cc::sptr":
        r"""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: "double") -> "void":
        r"""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) -> "unsigned int":
        r"""history(rotator_cc_sptr self) -> unsigned int"""
        return _blocks_swig5.rotator_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(rotator_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.rotator_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(rotator_cc_sptr self, int multiple)"""
        return _blocks_swig5.rotator_cc_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(rotator_cc_sptr self) -> uint64_t"""
        return _blocks_swig5.rotator_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(rotator_cc_sptr self) -> uint64_t"""
        return _blocks_swig5.rotator_cc_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(rotator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.rotator_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(rotator_cc_sptr self, std::string level)"""
        return _blocks_swig5.rotator_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(rotator_cc_sptr self) -> std::string"""
        return _blocks_swig5.rotator_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(rotator_cc_sptr self) -> float"""
        return _blocks_swig5.rotator_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(rotator_cc_sptr self)"""
        return _blocks_swig5.rotator_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(rotator_cc_sptr self) -> int"""
        return _blocks_swig5.rotator_cc_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(rotator_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rotator_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(rotator_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.rotator_cc_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(rotator_cc_sptr self) -> std::string"""
        return _blocks_swig5.rotator_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(rotator_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.rotator_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(rotator_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(rotator_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(rotator_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.rotator_cc_sptr_message_subscribers(self, which_port)

# Register rotator_cc_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sample_and_hold< std::uint8_t > class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::blocks::sample_and_hold< unsigned char >::sptr":
        r"""make() -> sample_and_hold_bb_sptr"""
        return _blocks_swig5.sample_and_hold_bb_make()
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_bb

# Register sample_and_hold_bb in _blocks_swig5:
_blocks_swig5.sample_and_hold_bb_swigregister(sample_and_hold_bb)

def sample_and_hold_bb_make() -> "gr::blocks::sample_and_hold< unsigned char >::sptr":
    r"""sample_and_hold_bb_make() -> sample_and_hold_bb_sptr"""
    return _blocks_swig5.sample_and_hold_bb_make()

class sample_and_hold_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sample_and_hold< std::uint8_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sample_and_hold_bb_sptr self) -> sample_and_hold_bb_sptr
        __init__(sample_and_hold_bb_sptr self, sample_and_hold_bb p) -> sample_and_hold_bb_sptr
        """
        _blocks_swig5.sample_and_hold_bb_sptr_swiginit(self, _blocks_swig5.new_sample_and_hold_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::sample_and_hold< std::uint8_t > *":
        r"""__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

    def make(self) -> "gr::blocks::sample_and_hold< unsigned char >::sptr":
        r"""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) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sample_and_hold_bb_sptr self, int multiple)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sample_and_hold_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sample_and_hold_bb_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_bb_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sample_and_hold_bb_sptr self, std::string level)"""
        return _blocks_swig5.sample_and_hold_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sample_and_hold_bb_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(sample_and_hold_bb_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sample_and_hold_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sample_and_hold_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sample_and_hold_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sample_and_hold_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sample_and_hold_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_bb_sptr_message_subscribers(self, which_port)

# Register sample_and_hold_bb_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sample_and_hold< std::int16_t > class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::blocks::sample_and_hold< short >::sptr":
        r"""make() -> sample_and_hold_ss_sptr"""
        return _blocks_swig5.sample_and_hold_ss_make()
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ss

# Register sample_and_hold_ss in _blocks_swig5:
_blocks_swig5.sample_and_hold_ss_swigregister(sample_and_hold_ss)

def sample_and_hold_ss_make() -> "gr::blocks::sample_and_hold< short >::sptr":
    r"""sample_and_hold_ss_make() -> sample_and_hold_ss_sptr"""
    return _blocks_swig5.sample_and_hold_ss_make()

class sample_and_hold_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sample_and_hold< std::int16_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sample_and_hold_ss_sptr self) -> sample_and_hold_ss_sptr
        __init__(sample_and_hold_ss_sptr self, sample_and_hold_ss p) -> sample_and_hold_ss_sptr
        """
        _blocks_swig5.sample_and_hold_ss_sptr_swiginit(self, _blocks_swig5.new_sample_and_hold_ss_sptr(*args))

    def __deref__(self) -> "gr::blocks::sample_and_hold< std::int16_t > *":
        r"""__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

    def make(self) -> "gr::blocks::sample_and_hold< short >::sptr":
        r"""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) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sample_and_hold_ss_sptr self, int multiple)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sample_and_hold_ss_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sample_and_hold_ss_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ss_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sample_and_hold_ss_sptr self, std::string level)"""
        return _blocks_swig5.sample_and_hold_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sample_and_hold_ss_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(sample_and_hold_ss_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sample_and_hold_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sample_and_hold_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sample_and_hold_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sample_and_hold_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ss_sptr_message_subscribers(self, which_port)

# Register sample_and_hold_ss_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sample_and_hold< std::int32_t > class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::blocks::sample_and_hold< int >::sptr":
        r"""make() -> sample_and_hold_ii_sptr"""
        return _blocks_swig5.sample_and_hold_ii_make()
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ii

# Register sample_and_hold_ii in _blocks_swig5:
_blocks_swig5.sample_and_hold_ii_swigregister(sample_and_hold_ii)

def sample_and_hold_ii_make() -> "gr::blocks::sample_and_hold< int >::sptr":
    r"""sample_and_hold_ii_make() -> sample_and_hold_ii_sptr"""
    return _blocks_swig5.sample_and_hold_ii_make()

class sample_and_hold_ii_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sample_and_hold< std::int32_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sample_and_hold_ii_sptr self) -> sample_and_hold_ii_sptr
        __init__(sample_and_hold_ii_sptr self, sample_and_hold_ii p) -> sample_and_hold_ii_sptr
        """
        _blocks_swig5.sample_and_hold_ii_sptr_swiginit(self, _blocks_swig5.new_sample_and_hold_ii_sptr(*args))

    def __deref__(self) -> "gr::blocks::sample_and_hold< std::int32_t > *":
        r"""__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

    def make(self) -> "gr::blocks::sample_and_hold< int >::sptr":
        r"""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) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sample_and_hold_ii_sptr self, int multiple)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sample_and_hold_ii_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ii_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sample_and_hold_ii_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ii_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sample_and_hold_ii_sptr self, std::string level)"""
        return _blocks_swig5.sample_and_hold_ii_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sample_and_hold_ii_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ii_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(sample_and_hold_ii_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ii_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sample_and_hold_ii_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ii_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sample_and_hold_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sample_and_hold_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sample_and_hold_ii_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ii_sptr_message_subscribers(self, which_port)

# Register sample_and_hold_ii_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sample_and_hold< float > class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::blocks::sample_and_hold< float >::sptr":
        r"""make() -> sample_and_hold_ff_sptr"""
        return _blocks_swig5.sample_and_hold_ff_make()
    __swig_destroy__ = _blocks_swig5.delete_sample_and_hold_ff

# Register sample_and_hold_ff in _blocks_swig5:
_blocks_swig5.sample_and_hold_ff_swigregister(sample_and_hold_ff)

def sample_and_hold_ff_make() -> "gr::blocks::sample_and_hold< float >::sptr":
    r"""sample_and_hold_ff_make() -> sample_and_hold_ff_sptr"""
    return _blocks_swig5.sample_and_hold_ff_make()

class sample_and_hold_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sample_and_hold< float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sample_and_hold_ff_sptr self) -> sample_and_hold_ff_sptr
        __init__(sample_and_hold_ff_sptr self, sample_and_hold_ff p) -> sample_and_hold_ff_sptr
        """
        _blocks_swig5.sample_and_hold_ff_sptr_swiginit(self, _blocks_swig5.new_sample_and_hold_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::sample_and_hold< float > *":
        r"""__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

    def make(self) -> "gr::blocks::sample_and_hold< float >::sptr":
        r"""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) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sample_and_hold_ff_sptr self, int multiple)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sample_and_hold_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sample_and_hold_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.sample_and_hold_ff_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sample_and_hold_ff_sptr self, std::string level)"""
        return _blocks_swig5.sample_and_hold_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sample_and_hold_ff_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(sample_and_hold_ff_sptr self) -> std::string"""
        return _blocks_swig5.sample_and_hold_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sample_and_hold_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sample_and_hold_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sample_and_hold_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sample_and_hold_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sample_and_hold_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sample_and_hold_ff_sptr_message_subscribers(self, which_port)

# Register sample_and_hold_ff_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::short_to_char > class."""

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

    def __init__(self, *args):
        r"""
        __init__(short_to_char_sptr self) -> short_to_char_sptr
        __init__(short_to_char_sptr self, short_to_char p) -> short_to_char_sptr
        """
        _blocks_swig5.short_to_char_sptr_swiginit(self, _blocks_swig5.new_short_to_char_sptr(*args))

    def __deref__(self) -> "gr::blocks::short_to_char *":
        r"""__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

    def make(self, vlen: "size_t"=1) -> "gr::blocks::short_to_char::sptr":
        r"""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) -> "unsigned int":
        r"""history(short_to_char_sptr self) -> unsigned int"""
        return _blocks_swig5.short_to_char_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(short_to_char_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.short_to_char_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(short_to_char_sptr self, int multiple)"""
        return _blocks_swig5.short_to_char_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(short_to_char_sptr self) -> double"""
        return _blocks_swig5.short_to_char_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(short_to_char_sptr self) -> uint64_t"""
        return _blocks_swig5.short_to_char_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(short_to_char_sptr self) -> uint64_t"""
        return _blocks_swig5.short_to_char_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(short_to_char_sptr self) -> bool"""
        return _blocks_swig5.short_to_char_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(short_to_char_sptr self) -> bool"""
        return _blocks_swig5.short_to_char_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(short_to_char_sptr self, std::string level)"""
        return _blocks_swig5.short_to_char_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(short_to_char_sptr self) -> float"""
        return _blocks_swig5.short_to_char_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(short_to_char_sptr self)"""
        return _blocks_swig5.short_to_char_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(short_to_char_sptr self) -> int"""
        return _blocks_swig5.short_to_char_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(short_to_char_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_char_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(short_to_char_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_char_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(short_to_char_sptr self) -> long"""
        return _blocks_swig5.short_to_char_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(short_to_char_sptr self) -> std::string"""
        return _blocks_swig5.short_to_char_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(short_to_char_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.short_to_char_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(short_to_char_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(short_to_char_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(short_to_char_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_char_sptr_message_subscribers(self, which_port)

# Register short_to_char_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::short_to_float > class."""

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

    def __init__(self, *args):
        r"""
        __init__(short_to_float_sptr self) -> short_to_float_sptr
        __init__(short_to_float_sptr self, short_to_float p) -> short_to_float_sptr
        """
        _blocks_swig5.short_to_float_sptr_swiginit(self, _blocks_swig5.new_short_to_float_sptr(*args))

    def __deref__(self) -> "gr::blocks::short_to_float *":
        r"""__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

    def make(self, vlen: "size_t"=1, scale: "float"=1.0) -> "gr::blocks::short_to_float::sptr":
        r"""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) -> "float":
        r"""scale(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_scale(self)

    def set_scale(self, scale: "float") -> "void":
        r"""set_scale(short_to_float_sptr self, float scale)"""
        return _blocks_swig5.short_to_float_sptr_set_scale(self, scale)

    def history(self) -> "unsigned int":
        r"""history(short_to_float_sptr self) -> unsigned int"""
        return _blocks_swig5.short_to_float_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(short_to_float_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.short_to_float_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(short_to_float_sptr self, int multiple)"""
        return _blocks_swig5.short_to_float_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(short_to_float_sptr self) -> double"""
        return _blocks_swig5.short_to_float_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(short_to_float_sptr self) -> uint64_t"""
        return _blocks_swig5.short_to_float_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(short_to_float_sptr self) -> uint64_t"""
        return _blocks_swig5.short_to_float_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(short_to_float_sptr self) -> bool"""
        return _blocks_swig5.short_to_float_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(short_to_float_sptr self) -> bool"""
        return _blocks_swig5.short_to_float_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(short_to_float_sptr self, std::string level)"""
        return _blocks_swig5.short_to_float_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(short_to_float_sptr self) -> float"""
        return _blocks_swig5.short_to_float_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(short_to_float_sptr self)"""
        return _blocks_swig5.short_to_float_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(short_to_float_sptr self) -> int"""
        return _blocks_swig5.short_to_float_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(short_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_float_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(short_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.short_to_float_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(short_to_float_sptr self) -> long"""
        return _blocks_swig5.short_to_float_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(short_to_float_sptr self) -> std::string"""
        return _blocks_swig5.short_to_float_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(short_to_float_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.short_to_float_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(short_to_float_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(short_to_float_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(short_to_float_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.short_to_float_sptr_message_subscribers(self, which_port)

# Register short_to_float_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::socket_pdu > class."""

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

    def __init__(self, *args):
        r"""
        __init__(socket_pdu_sptr self) -> socket_pdu_sptr
        __init__(socket_pdu_sptr self, socket_pdu p) -> socket_pdu_sptr
        """
        _blocks_swig5.socket_pdu_sptr_swiginit(self, _blocks_swig5.new_socket_pdu_sptr(*args))

    def __deref__(self) -> "gr::blocks::socket_pdu *":
        r"""__deref__(socket_pdu_sptr self) -> socket_pdu"""
        return _blocks_swig5.socket_pdu_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_socket_pdu_sptr

    def make(self, type: "std::string", addr: "std::string", port: "std::string", MTU: "int"=10000, tcp_no_delay: "bool"=False) -> "gr::blocks::socket_pdu::sptr":
        r"""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) -> "unsigned int":
        r"""history(socket_pdu_sptr self) -> unsigned int"""
        return _blocks_swig5.socket_pdu_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(socket_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.socket_pdu_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(socket_pdu_sptr self, int multiple)"""
        return _blocks_swig5.socket_pdu_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(socket_pdu_sptr self) -> double"""
        return _blocks_swig5.socket_pdu_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(socket_pdu_sptr self) -> uint64_t"""
        return _blocks_swig5.socket_pdu_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(socket_pdu_sptr self) -> uint64_t"""
        return _blocks_swig5.socket_pdu_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(socket_pdu_sptr self) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(socket_pdu_sptr self) -> bool"""
        return _blocks_swig5.socket_pdu_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(socket_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.socket_pdu_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(socket_pdu_sptr self, std::string level)"""
        return _blocks_swig5.socket_pdu_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(socket_pdu_sptr self) -> float"""
        return _blocks_swig5.socket_pdu_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(socket_pdu_sptr self)"""
        return _blocks_swig5.socket_pdu_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(socket_pdu_sptr self) -> int"""
        return _blocks_swig5.socket_pdu_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(socket_pdu_sptr self, int priority) -> int"""
        return _blocks_swig5.socket_pdu_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(socket_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.socket_pdu_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(socket_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.socket_pdu_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(socket_pdu_sptr self) -> long"""
        return _blocks_swig5.socket_pdu_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(socket_pdu_sptr self) -> std::string"""
        return _blocks_swig5.socket_pdu_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(socket_pdu_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.socket_pdu_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(socket_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(socket_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(socket_pdu_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.socket_pdu_sptr_message_subscribers(self, which_port)

# Register socket_pdu_sptr in _blocks_swig5:
_blocks_swig5.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):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::stretch_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(stretch_ff_sptr self) -> stretch_ff_sptr
        __init__(stretch_ff_sptr self, stretch_ff p) -> stretch_ff_sptr
        """
        _blocks_swig5.stretch_ff_sptr_swiginit(self, _blocks_swig5.new_stretch_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::stretch_ff *":
        r"""__deref__(stretch_ff_sptr self) -> stretch_ff"""
        return _blocks_swig5.stretch_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_stretch_ff_sptr

    def make(self, lo: "float", vlen: "size_t"=1) -> "gr::blocks::stretch_ff::sptr":
        r"""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) -> "float":
        r"""lo(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_lo(self)

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(stretch_ff_sptr self, float lo)"""
        return _blocks_swig5.stretch_ff_sptr_set_lo(self, lo)

    def vlen(self) -> "size_t":
        r"""vlen(stretch_ff_sptr self) -> size_t"""
        return _blocks_swig5.stretch_ff_sptr_vlen(self)

    def history(self) -> "unsigned int":
        r"""history(stretch_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.stretch_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(stretch_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.stretch_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(stretch_ff_sptr self, int multiple)"""
        return _blocks_swig5.stretch_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(stretch_ff_sptr self) -> double"""
        return _blocks_swig5.stretch_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(stretch_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.stretch_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(stretch_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.stretch_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(stretch_ff_sptr self) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(stretch_ff_sptr self) -> bool"""
        return _blocks_swig5.stretch_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(stretch_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.stretch_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(stretch_ff_sptr self, std::string level)"""
        return _blocks_swig5.stretch_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(stretch_ff_sptr self) -> float"""
        return _blocks_swig5.stretch_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(stretch_ff_sptr self)"""
        return _blocks_swig5.stretch_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(stretch_ff_sptr self) -> int"""
        return _blocks_swig5.stretch_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(stretch_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.stretch_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(stretch_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.stretch_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(stretch_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.stretch_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(stretch_ff_sptr self) -> long"""
        return _blocks_swig5.stretch_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(stretch_ff_sptr self) -> std::string"""
        return _blocks_swig5.stretch_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(stretch_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.stretch_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(stretch_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(stretch_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(stretch_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.stretch_ff_sptr_message_subscribers(self, which_port)

# Register stretch_ff_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sub< float > class."""

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::blocks::sub< float >::sptr":
        r"""make(size_t vlen=1) -> sub_ff_sptr"""
        return _blocks_swig5.sub_ff_make(vlen)
    __swig_destroy__ = _blocks_swig5.delete_sub_ff

# Register sub_ff in _blocks_swig5:
_blocks_swig5.sub_ff_swigregister(sub_ff)

def sub_ff_make(vlen: "size_t"=1) -> "gr::blocks::sub< float >::sptr":
    r"""sub_ff_make(size_t vlen=1) -> sub_ff_sptr"""
    return _blocks_swig5.sub_ff_make(vlen)

class sub_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sub< float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sub_ff_sptr self) -> sub_ff_sptr
        __init__(sub_ff_sptr self, sub_ff p) -> sub_ff_sptr
        """
        _blocks_swig5.sub_ff_sptr_swiginit(self, _blocks_swig5.new_sub_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::sub< float > *":
        r"""__deref__(sub_ff_sptr self) -> sub_ff"""
        return _blocks_swig5.sub_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_sub_ff_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::sub< float >::sptr":
        r"""make(sub_ff_sptr self, size_t vlen=1) -> sub_ff_sptr"""
        return _blocks_swig5.sub_ff_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(sub_ff_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sub_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sub_ff_sptr self, int multiple)"""
        return _blocks_swig5.sub_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sub_ff_sptr self) -> double"""
        return _blocks_swig5.sub_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sub_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sub_ff_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sub_ff_sptr self) -> bool"""
        return _blocks_swig5.sub_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sub_ff_sptr self) -> bool"""
        return _blocks_swig5.sub_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sub_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sub_ff_sptr self, std::string level)"""
        return _blocks_swig5.sub_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sub_ff_sptr self) -> float"""
        return _blocks_swig5.sub_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sub_ff_sptr self)"""
        return _blocks_swig5.sub_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sub_ff_sptr self) -> int"""
        return _blocks_swig5.sub_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sub_ff_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sub_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sub_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sub_ff_sptr self) -> long"""
        return _blocks_swig5.sub_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sub_ff_sptr self) -> std::string"""
        return _blocks_swig5.sub_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sub_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sub_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sub_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sub_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sub_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ff_sptr_message_subscribers(self, which_port)

# Register sub_ff_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sub< std::int16_t > class."""

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::blocks::sub< short >::sptr":
        r"""make(size_t vlen=1) -> sub_ss_sptr"""
        return _blocks_swig5.sub_ss_make(vlen)
    __swig_destroy__ = _blocks_swig5.delete_sub_ss

# Register sub_ss in _blocks_swig5:
_blocks_swig5.sub_ss_swigregister(sub_ss)

def sub_ss_make(vlen: "size_t"=1) -> "gr::blocks::sub< short >::sptr":
    r"""sub_ss_make(size_t vlen=1) -> sub_ss_sptr"""
    return _blocks_swig5.sub_ss_make(vlen)

class sub_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sub< std::int16_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sub_ss_sptr self) -> sub_ss_sptr
        __init__(sub_ss_sptr self, sub_ss p) -> sub_ss_sptr
        """
        _blocks_swig5.sub_ss_sptr_swiginit(self, _blocks_swig5.new_sub_ss_sptr(*args))

    def __deref__(self) -> "gr::blocks::sub< std::int16_t > *":
        r"""__deref__(sub_ss_sptr self) -> sub_ss"""
        return _blocks_swig5.sub_ss_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_sub_ss_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::sub< short >::sptr":
        r"""make(sub_ss_sptr self, size_t vlen=1) -> sub_ss_sptr"""
        return _blocks_swig5.sub_ss_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(sub_ss_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sub_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sub_ss_sptr self, int multiple)"""
        return _blocks_swig5.sub_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sub_ss_sptr self) -> double"""
        return _blocks_swig5.sub_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sub_ss_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sub_ss_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sub_ss_sptr self) -> bool"""
        return _blocks_swig5.sub_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sub_ss_sptr self) -> bool"""
        return _blocks_swig5.sub_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sub_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sub_ss_sptr self, std::string level)"""
        return _blocks_swig5.sub_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sub_ss_sptr self) -> float"""
        return _blocks_swig5.sub_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sub_ss_sptr self)"""
        return _blocks_swig5.sub_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sub_ss_sptr self) -> int"""
        return _blocks_swig5.sub_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sub_ss_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sub_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sub_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sub_ss_sptr self) -> long"""
        return _blocks_swig5.sub_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sub_ss_sptr self) -> std::string"""
        return _blocks_swig5.sub_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sub_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sub_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sub_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sub_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sub_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ss_sptr_message_subscribers(self, which_port)

# Register sub_ss_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sub< std::int32_t > class."""

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::blocks::sub< int >::sptr":
        r"""make(size_t vlen=1) -> sub_ii_sptr"""
        return _blocks_swig5.sub_ii_make(vlen)
    __swig_destroy__ = _blocks_swig5.delete_sub_ii

# Register sub_ii in _blocks_swig5:
_blocks_swig5.sub_ii_swigregister(sub_ii)

def sub_ii_make(vlen: "size_t"=1) -> "gr::blocks::sub< int >::sptr":
    r"""sub_ii_make(size_t vlen=1) -> sub_ii_sptr"""
    return _blocks_swig5.sub_ii_make(vlen)

class sub_ii_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sub< std::int32_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sub_ii_sptr self) -> sub_ii_sptr
        __init__(sub_ii_sptr self, sub_ii p) -> sub_ii_sptr
        """
        _blocks_swig5.sub_ii_sptr_swiginit(self, _blocks_swig5.new_sub_ii_sptr(*args))

    def __deref__(self) -> "gr::blocks::sub< std::int32_t > *":
        r"""__deref__(sub_ii_sptr self) -> sub_ii"""
        return _blocks_swig5.sub_ii_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_sub_ii_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::sub< int >::sptr":
        r"""make(sub_ii_sptr self, size_t vlen=1) -> sub_ii_sptr"""
        return _blocks_swig5.sub_ii_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(sub_ii_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_ii_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sub_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_ii_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sub_ii_sptr self, int multiple)"""
        return _blocks_swig5.sub_ii_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sub_ii_sptr self) -> double"""
        return _blocks_swig5.sub_ii_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sub_ii_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ii_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sub_ii_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_ii_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sub_ii_sptr self) -> bool"""
        return _blocks_swig5.sub_ii_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sub_ii_sptr self) -> bool"""
        return _blocks_swig5.sub_ii_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sub_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_ii_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sub_ii_sptr self, std::string level)"""
        return _blocks_swig5.sub_ii_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sub_ii_sptr self) -> float"""
        return _blocks_swig5.sub_ii_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sub_ii_sptr self)"""
        return _blocks_swig5.sub_ii_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sub_ii_sptr self) -> int"""
        return _blocks_swig5.sub_ii_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sub_ii_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_ii_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sub_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ii_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sub_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_ii_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sub_ii_sptr self) -> long"""
        return _blocks_swig5.sub_ii_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sub_ii_sptr self) -> std::string"""
        return _blocks_swig5.sub_ii_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sub_ii_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sub_ii_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sub_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sub_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sub_ii_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_ii_sptr_message_subscribers(self, which_port)

# Register sub_ii_sptr in _blocks_swig5:
_blocks_swig5.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(object):
    r"""Proxy of C++ gr::blocks::sub< gr_complex > class."""

    thisown = 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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::blocks::sub< std::complex< float > >::sptr":
        r"""make(size_t vlen=1) -> sub_cc_sptr"""
        return _blocks_swig5.sub_cc_make(vlen)
    __swig_destroy__ = _blocks_swig5.delete_sub_cc

# Register sub_cc in _blocks_swig5:
_blocks_swig5.sub_cc_swigregister(sub_cc)

def sub_cc_make(vlen: "size_t"=1) -> "gr::blocks::sub< std::complex< float > >::sptr":
    r"""sub_cc_make(size_t vlen=1) -> sub_cc_sptr"""
    return _blocks_swig5.sub_cc_make(vlen)

class sub_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::sub< gr_complex > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sub_cc_sptr self) -> sub_cc_sptr
        __init__(sub_cc_sptr self, sub_cc p) -> sub_cc_sptr
        """
        _blocks_swig5.sub_cc_sptr_swiginit(self, _blocks_swig5.new_sub_cc_sptr(*args))

    def __deref__(self) -> "gr::blocks::sub< gr_complex > *":
        r"""__deref__(sub_cc_sptr self) -> sub_cc"""
        return _blocks_swig5.sub_cc_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig5.delete_sub_cc_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::sub< std::complex< float > >::sptr":
        r"""make(sub_cc_sptr self, size_t vlen=1) -> sub_cc_sptr"""
        return _blocks_swig5.sub_cc_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(sub_cc_sptr self) -> unsigned int"""
        return _blocks_swig5.sub_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sub_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig5.sub_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sub_cc_sptr self, int multiple)"""
        return _blocks_swig5.sub_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(sub_cc_sptr self) -> double"""
        return _blocks_swig5.sub_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sub_cc_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sub_cc_sptr self) -> uint64_t"""
        return _blocks_swig5.sub_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(sub_cc_sptr self) -> bool"""
        return _blocks_swig5.sub_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(sub_cc_sptr self) -> bool"""
        return _blocks_swig5.sub_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sub_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig5.sub_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sub_cc_sptr self, std::string level)"""
        return _blocks_swig5.sub_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sub_cc_sptr self) -> float"""
        return _blocks_swig5.sub_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sub_cc_sptr self)"""
        return _blocks_swig5.sub_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(sub_cc_sptr self) -> int"""
        return _blocks_swig5.sub_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(sub_cc_sptr self, int priority) -> int"""
        return _blocks_swig5.sub_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sub_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sub_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig5.sub_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sub_cc_sptr self) -> long"""
        return _blocks_swig5.sub_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sub_cc_sptr self) -> std::string"""
        return _blocks_swig5.sub_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sub_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig5.sub_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sub_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sub_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sub_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig5.sub_cc_sptr_message_subscribers(self, which_port)

# Register sub_cc_sptr in _blocks_swig5:
_blocks_swig5.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



