# 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_swig6
else:
    import _blocks_swig6

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_swig6.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_swig6.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_swig6.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_swig6.high_res_timer_epoch()
byte_t = _blocks_swig6.byte_t

float_t = _blocks_swig6.float_t

complex_t = _blocks_swig6.complex_t


def pdu_port_id() -> "pmt::pmt_t const":
    r"""pdu_port_id() -> swig_pmt_ptr"""
    return _blocks_swig6.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_swig6.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_swig6.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_swig6.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_swig6.type_from_pmt(vector)
class tag_gate(object):
    r"""Proxy of C++ gr::blocks::tag_gate 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

    def set_propagation(self, propagate_tags: "bool") -> "void":
        r"""set_propagation(tag_gate self, bool propagate_tags)"""
        return _blocks_swig6.tag_gate_set_propagation(self, propagate_tags)

    @staticmethod
    def make(item_size: "size_t", propagate_tags: "bool"=False) -> "gr::blocks::tag_gate::sptr":
        r"""make(size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
        return _blocks_swig6.tag_gate_make(item_size, propagate_tags)

    def set_single_key(self, single_key: "std::string const &") -> "void":
        r"""set_single_key(tag_gate self, std::string const & single_key)"""
        return _blocks_swig6.tag_gate_set_single_key(self, single_key)

    def single_key(self) -> "std::string":
        r"""single_key(tag_gate self) -> std::string"""
        return _blocks_swig6.tag_gate_single_key(self)
    __swig_destroy__ = _blocks_swig6.delete_tag_gate

# Register tag_gate in _blocks_swig6:
_blocks_swig6.tag_gate_swigregister(tag_gate)

def tag_gate_make(item_size: "size_t", propagate_tags: "bool"=False) -> "gr::blocks::tag_gate::sptr":
    r"""tag_gate_make(size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
    return _blocks_swig6.tag_gate_make(item_size, propagate_tags)

class tag_share(object):
    r"""Proxy of C++ gr::blocks::tag_share 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(sizeof_io_item: "size_t", sizeof_share_item: "size_t", vlen: "size_t"=1) -> "gr::blocks::tag_share::sptr":
        r"""make(size_t sizeof_io_item, size_t sizeof_share_item, size_t vlen=1) -> tag_share_sptr"""
        return _blocks_swig6.tag_share_make(sizeof_io_item, sizeof_share_item, vlen)
    __swig_destroy__ = _blocks_swig6.delete_tag_share

# Register tag_share in _blocks_swig6:
_blocks_swig6.tag_share_swigregister(tag_share)

def tag_share_make(sizeof_io_item: "size_t", sizeof_share_item: "size_t", vlen: "size_t"=1) -> "gr::blocks::tag_share::sptr":
    r"""tag_share_make(size_t sizeof_io_item, size_t sizeof_share_item, size_t vlen=1) -> tag_share_sptr"""
    return _blocks_swig6.tag_share_make(sizeof_io_item, sizeof_share_item, vlen)

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

# Register tagged_stream_align in _blocks_swig6:
_blocks_swig6.tagged_stream_align_swigregister(tagged_stream_align)

def tagged_stream_align_make(itemsize: "size_t", lengthtagname: "std::string const &") -> "gr::blocks::tagged_stream_align::sptr":
    r"""tagged_stream_align_make(size_t itemsize, std::string const & lengthtagname) -> tagged_stream_align_sptr"""
    return _blocks_swig6.tagged_stream_align_make(itemsize, lengthtagname)

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

# Register tagged_stream_mux in _blocks_swig6:
_blocks_swig6.tagged_stream_mux_swigregister(tagged_stream_mux)

def tagged_stream_mux_make(itemsize: "size_t", lengthtagname: "std::string const &", tag_preserve_head_pos: "unsigned int"=0) -> "gr::blocks::tagged_stream_mux::sptr":
    r"""tagged_stream_mux_make(size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) -> tagged_stream_mux_sptr"""
    return _blocks_swig6.tagged_stream_mux_make(itemsize, lengthtagname, tag_preserve_head_pos)

class tagged_stream_multiply_length(object):
    r"""Proxy of C++ gr::blocks::tagged_stream_multiply_length 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

    def set_scalar(self, scalar: "double") -> "void":
        r"""set_scalar(tagged_stream_multiply_length self, double scalar)"""
        return _blocks_swig6.tagged_stream_multiply_length_set_scalar(self, scalar)

    @staticmethod
    def make(itemsize: "size_t", lengthtagname: "std::string const &", scalar: "double") -> "gr::blocks::tagged_stream_multiply_length::sptr":
        r"""make(size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
        return _blocks_swig6.tagged_stream_multiply_length_make(itemsize, lengthtagname, scalar)
    __swig_destroy__ = _blocks_swig6.delete_tagged_stream_multiply_length

# Register tagged_stream_multiply_length in _blocks_swig6:
_blocks_swig6.tagged_stream_multiply_length_swigregister(tagged_stream_multiply_length)

def tagged_stream_multiply_length_make(itemsize: "size_t", lengthtagname: "std::string const &", scalar: "double") -> "gr::blocks::tagged_stream_multiply_length::sptr":
    r"""tagged_stream_multiply_length_make(size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
    return _blocks_swig6.tagged_stream_multiply_length_make(itemsize, lengthtagname, scalar)

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

# Register tagged_stream_to_pdu in _blocks_swig6:
_blocks_swig6.tagged_stream_to_pdu_swigregister(tagged_stream_to_pdu)

def tagged_stream_to_pdu_make(*args, **kwargs) -> "gr::blocks::tagged_stream_to_pdu::sptr":
    r"""tagged_stream_to_pdu_make(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") -> tagged_stream_to_pdu_sptr"""
    return _blocks_swig6.tagged_stream_to_pdu_make(*args, **kwargs)

class tags_strobe(object):
    r"""Proxy of C++ gr::blocks::tags_strobe 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::tags_strobe::sptr":
        r"""make(size_t sizeof_stream_item, swig_pmt_ptr value, uint64_t nsamps, swig_pmt_ptr key=pmt::intern("strobe")) -> tags_strobe_sptr"""
        return _blocks_swig6.tags_strobe_make(*args, **kwargs)

    def set_value(self, value: "swig_pmt_ptr") -> "void":
        r"""set_value(tags_strobe self, swig_pmt_ptr value)"""
        return _blocks_swig6.tags_strobe_set_value(self, value)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(tags_strobe self, swig_pmt_ptr key)"""
        return _blocks_swig6.tags_strobe_set_key(self, key)

    def value(self) -> "pmt::pmt_t":
        r"""value(tags_strobe self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_value(self)

    def key(self) -> "pmt::pmt_t":
        r"""key(tags_strobe self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_key(self)

    def set_nsamps(self, nsamps: "uint64_t") -> "void":
        r"""set_nsamps(tags_strobe self, uint64_t nsamps)"""
        return _blocks_swig6.tags_strobe_set_nsamps(self, nsamps)

    def nsamps(self) -> "uint64_t":
        r"""nsamps(tags_strobe self) -> uint64_t"""
        return _blocks_swig6.tags_strobe_nsamps(self)
    __swig_destroy__ = _blocks_swig6.delete_tags_strobe

# Register tags_strobe in _blocks_swig6:
_blocks_swig6.tags_strobe_swigregister(tags_strobe)

def tags_strobe_make(*args, **kwargs) -> "gr::blocks::tags_strobe::sptr":
    r"""tags_strobe_make(size_t sizeof_stream_item, swig_pmt_ptr value, uint64_t nsamps, swig_pmt_ptr key=pmt::intern("strobe")) -> tags_strobe_sptr"""
    return _blocks_swig6.tags_strobe_make(*args, **kwargs)

class tcp_server_sink(object):
    r"""Proxy of C++ gr::blocks::tcp_server_sink 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(itemsize: "size_t", host: "std::string const &", port: "int", noblock: "bool"=False) -> "gr::blocks::tcp_server_sink::sptr":
        r"""make(size_t itemsize, std::string const & host, int port, bool noblock=False) -> tcp_server_sink_sptr"""
        return _blocks_swig6.tcp_server_sink_make(itemsize, host, port, noblock)
    __swig_destroy__ = _blocks_swig6.delete_tcp_server_sink

# Register tcp_server_sink in _blocks_swig6:
_blocks_swig6.tcp_server_sink_swigregister(tcp_server_sink)

def tcp_server_sink_make(itemsize: "size_t", host: "std::string const &", port: "int", noblock: "bool"=False) -> "gr::blocks::tcp_server_sink::sptr":
    r"""tcp_server_sink_make(size_t itemsize, std::string const & host, int port, bool noblock=False) -> tcp_server_sink_sptr"""
    return _blocks_swig6.tcp_server_sink_make(itemsize, host, port, noblock)

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

    @staticmethod
    def make(update_once: "bool"=False, update_step: "double"=0.001) -> "gr::blocks::test_tag_variable_rate_ff::sptr":
        r"""make(bool update_once=False, double update_step=0.001) -> test_tag_variable_rate_ff_sptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_make(update_once, update_step)
    __swig_destroy__ = _blocks_swig6.delete_test_tag_variable_rate_ff

# Register test_tag_variable_rate_ff in _blocks_swig6:
_blocks_swig6.test_tag_variable_rate_ff_swigregister(test_tag_variable_rate_ff)

def test_tag_variable_rate_ff_make(update_once: "bool"=False, update_step: "double"=0.001) -> "gr::blocks::test_tag_variable_rate_ff::sptr":
    r"""test_tag_variable_rate_ff_make(bool update_once=False, double update_step=0.001) -> test_tag_variable_rate_ff_sptr"""
    return _blocks_swig6.test_tag_variable_rate_ff_make(update_once, update_step)

class threshold_ff(object):
    r"""Proxy of C++ gr::blocks::threshold_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", hi: "float", initial_state: "float"=0) -> "gr::blocks::threshold_ff::sptr":
        r"""make(float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
        return _blocks_swig6.threshold_ff_make(lo, hi, initial_state)

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

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(threshold_ff self, float lo)"""
        return _blocks_swig6.threshold_ff_set_lo(self, lo)

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

    def set_hi(self, hi: "float") -> "void":
        r"""set_hi(threshold_ff self, float hi)"""
        return _blocks_swig6.threshold_ff_set_hi(self, hi)

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

    def set_last_state(self, last_state: "float") -> "void":
        r"""set_last_state(threshold_ff self, float last_state)"""
        return _blocks_swig6.threshold_ff_set_last_state(self, last_state)
    __swig_destroy__ = _blocks_swig6.delete_threshold_ff

# Register threshold_ff in _blocks_swig6:
_blocks_swig6.threshold_ff_swigregister(threshold_ff)

def threshold_ff_make(lo: "float", hi: "float", initial_state: "float"=0) -> "gr::blocks::threshold_ff::sptr":
    r"""threshold_ff_make(float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
    return _blocks_swig6.threshold_ff_make(lo, hi, initial_state)

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

# Register transcendental in _blocks_swig6:
_blocks_swig6.transcendental_swigregister(transcendental)

def transcendental_make(*args, **kwargs) -> "gr::blocks::transcendental::sptr":
    r"""transcendental_make(std::string const & name, std::string const & type="float") -> transcendental_sptr"""
    return _blocks_swig6.transcendental_make(*args, **kwargs)

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

# Register tuntap_pdu in _blocks_swig6:
_blocks_swig6.tuntap_pdu_swigregister(tuntap_pdu)

def tuntap_pdu_make(dev: "std::string", MTU: "int"=10000, istunflag: "bool"=False) -> "gr::blocks::tuntap_pdu::sptr":
    r"""tuntap_pdu_make(std::string dev, int MTU=10000, bool istunflag=False) -> tuntap_pdu_sptr"""
    return _blocks_swig6.tuntap_pdu_make(dev, MTU, istunflag)

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

    @staticmethod
    def make() -> "gr::blocks::uchar_to_float::sptr":
        r"""make() -> uchar_to_float_sptr"""
        return _blocks_swig6.uchar_to_float_make()
    __swig_destroy__ = _blocks_swig6.delete_uchar_to_float

# Register uchar_to_float in _blocks_swig6:
_blocks_swig6.uchar_to_float_swigregister(uchar_to_float)

def uchar_to_float_make() -> "gr::blocks::uchar_to_float::sptr":
    r"""uchar_to_float_make() -> uchar_to_float_sptr"""
    return _blocks_swig6.uchar_to_float_make()

class udp_sink(object):
    r"""Proxy of C++ gr::blocks::udp_sink 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", host: "std::string const &", port: "int", payload_size: "int"=1472, eof: "bool"=True) -> "gr::blocks::udp_sink::sptr":
        r"""make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
        return _blocks_swig6.udp_sink_make(itemsize, host, port, payload_size, eof)

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

    def connect(self, host: "std::string const &", port: "int") -> "void":
        r"""connect(udp_sink self, std::string const & host, int port)"""
        return _blocks_swig6.udp_sink_connect(self, host, port)

    def disconnect(self) -> "void":
        r"""disconnect(udp_sink self)"""
        return _blocks_swig6.udp_sink_disconnect(self)
    __swig_destroy__ = _blocks_swig6.delete_udp_sink

# Register udp_sink in _blocks_swig6:
_blocks_swig6.udp_sink_swigregister(udp_sink)

def udp_sink_make(itemsize: "size_t", host: "std::string const &", port: "int", payload_size: "int"=1472, eof: "bool"=True) -> "gr::blocks::udp_sink::sptr":
    r"""udp_sink_make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
    return _blocks_swig6.udp_sink_make(itemsize, host, port, payload_size, eof)

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

    def connect(self, host: "std::string const &", port: "int") -> "void":
        r"""connect(udp_source self, std::string const & host, int port)"""
        return _blocks_swig6.udp_source_connect(self, host, port)

    def disconnect(self) -> "void":
        r"""disconnect(udp_source self)"""
        return _blocks_swig6.udp_source_disconnect(self)

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

    def get_port(self) -> "int":
        r"""get_port(udp_source self) -> int"""
        return _blocks_swig6.udp_source_get_port(self)
    __swig_destroy__ = _blocks_swig6.delete_udp_source

# Register udp_source in _blocks_swig6:
_blocks_swig6.udp_source_swigregister(udp_source)

def udp_source_make(itemsize: "size_t", host: "std::string const &", port: "int", payload_size: "int"=1472, eof: "bool"=True) -> "gr::blocks::udp_source::sptr":
    r"""udp_source_make(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_source_sptr"""
    return _blocks_swig6.udp_source_make(itemsize, host, port, payload_size, eof)

class unpack_k_bits(object):
    r"""Proxy of C++ gr::blocks::kernel::unpack_k_bits 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, k: "unsigned int"):
        r"""__init__(unpack_k_bits self, unsigned int k) -> unpack_k_bits"""
        _blocks_swig6.unpack_k_bits_swiginit(self, _blocks_swig6.new_unpack_k_bits(k))
    __swig_destroy__ = _blocks_swig6.delete_unpack_k_bits

    def unpack(self, bits: "unsigned char *", bytes: "unsigned char const *", nbytes: "int") -> "void":
        r"""unpack(unpack_k_bits self, unsigned char * bits, unsigned char const * bytes, int nbytes)"""
        return _blocks_swig6.unpack_k_bits_unpack(self, bits, bytes, nbytes)

    def unpack_rev(self, bits: "unsigned char *", bytes: "unsigned char const *", nbytes: "int") -> "void":
        r"""unpack_rev(unpack_k_bits self, unsigned char * bits, unsigned char const * bytes, int nbytes)"""
        return _blocks_swig6.unpack_k_bits_unpack_rev(self, bits, bytes, nbytes)

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

# Register unpack_k_bits in _blocks_swig6:
_blocks_swig6.unpack_k_bits_swigregister(unpack_k_bits)

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

    @staticmethod
    def make(k: "unsigned int") -> "gr::blocks::unpack_k_bits_bb::sptr":
        r"""make(unsigned int k) -> unpack_k_bits_bb_sptr"""
        return _blocks_swig6.unpack_k_bits_bb_make(k)
    __swig_destroy__ = _blocks_swig6.delete_unpack_k_bits_bb

# Register unpack_k_bits_bb in _blocks_swig6:
_blocks_swig6.unpack_k_bits_bb_swigregister(unpack_k_bits_bb)

def unpack_k_bits_bb_make(k: "unsigned int") -> "gr::blocks::unpack_k_bits_bb::sptr":
    r"""unpack_k_bits_bb_make(unsigned int k) -> unpack_k_bits_bb_sptr"""
    return _blocks_swig6.unpack_k_bits_bb_make(k)

class vco_f(object):
    r"""Proxy of C++ gr::blocks::vco_f 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(sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_f::sptr":
        r"""make(double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
        return _blocks_swig6.vco_f_make(sampling_rate, sensitivity, amplitude)
    __swig_destroy__ = _blocks_swig6.delete_vco_f

# Register vco_f in _blocks_swig6:
_blocks_swig6.vco_f_swigregister(vco_f)

def vco_f_make(sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_f::sptr":
    r"""vco_f_make(double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
    return _blocks_swig6.vco_f_make(sampling_rate, sensitivity, amplitude)

class vco_c(object):
    r"""Proxy of C++ gr::blocks::vco_c 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(sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_c::sptr":
        r"""make(double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
        return _blocks_swig6.vco_c_make(sampling_rate, sensitivity, amplitude)
    __swig_destroy__ = _blocks_swig6.delete_vco_c

# Register vco_c in _blocks_swig6:
_blocks_swig6.vco_c_swigregister(vco_c)

def vco_c_make(sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_c::sptr":
    r"""vco_c_make(double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
    return _blocks_swig6.vco_c_make(sampling_rate, sensitivity, amplitude)

class tag_gate_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tag_gate > 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__(tag_gate_sptr self) -> tag_gate_sptr
        __init__(tag_gate_sptr self, tag_gate p) -> tag_gate_sptr
        """
        _blocks_swig6.tag_gate_sptr_swiginit(self, _blocks_swig6.new_tag_gate_sptr(*args))

    def __deref__(self) -> "gr::blocks::tag_gate *":
        r"""__deref__(tag_gate_sptr self) -> tag_gate"""
        return _blocks_swig6.tag_gate_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tag_gate_sptr

    def set_propagation(self, propagate_tags: "bool") -> "void":
        r"""set_propagation(tag_gate_sptr self, bool propagate_tags)"""
        return _blocks_swig6.tag_gate_sptr_set_propagation(self, propagate_tags)

    def make(self, item_size: "size_t", propagate_tags: "bool"=False) -> "gr::blocks::tag_gate::sptr":
        r"""make(tag_gate_sptr self, size_t item_size, bool propagate_tags=False) -> tag_gate_sptr"""
        return _blocks_swig6.tag_gate_sptr_make(self, item_size, propagate_tags)

    def set_single_key(self, single_key: "std::string const &") -> "void":
        r"""set_single_key(tag_gate_sptr self, std::string const & single_key)"""
        return _blocks_swig6.tag_gate_sptr_set_single_key(self, single_key)

    def single_key(self) -> "std::string":
        r"""single_key(tag_gate_sptr self) -> std::string"""
        return _blocks_swig6.tag_gate_sptr_single_key(self)

    def history(self) -> "unsigned int":
        r"""history(tag_gate_sptr self) -> unsigned int"""
        return _blocks_swig6.tag_gate_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tag_gate_sptr self, int which, int delay)
        declare_sample_delay(tag_gate_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tag_gate_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tag_gate_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tag_gate_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tag_gate_sptr self, int multiple)"""
        return _blocks_swig6.tag_gate_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tag_gate_sptr self) -> int"""
        return _blocks_swig6.tag_gate_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tag_gate_sptr self) -> double"""
        return _blocks_swig6.tag_gate_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tag_gate_sptr self) -> uint64_t"""
        return _blocks_swig6.tag_gate_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tag_gate_sptr self) -> uint64_t"""
        return _blocks_swig6.tag_gate_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tag_gate_sptr self) -> bool"""
        return _blocks_swig6.tag_gate_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tag_gate_sptr self) -> bool"""
        return _blocks_swig6.tag_gate_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tag_gate_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tag_gate_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tag_gate_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tag_gate_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tag_gate_sptr self, std::string level)"""
        return _blocks_swig6.tag_gate_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tag_gate_sptr self) -> std::string"""
        return _blocks_swig6.tag_gate_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tag_gate_sptr self) -> int"""
        return _blocks_swig6.tag_gate_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tag_gate_sptr self, int m)"""
        return _blocks_swig6.tag_gate_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tag_gate_sptr self)"""
        return _blocks_swig6.tag_gate_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tag_gate_sptr self) -> bool"""
        return _blocks_swig6.tag_gate_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tag_gate_sptr self, int m)"""
        return _blocks_swig6.tag_gate_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tag_gate_sptr self) -> int"""
        return _blocks_swig6.tag_gate_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tag_gate_sptr self, int i) -> long"""
        return _blocks_swig6.tag_gate_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tag_gate_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_gate_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tag_gate_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tag_gate_sptr self, int i) -> long"""
        return _blocks_swig6.tag_gate_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tag_gate_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_gate_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tag_gate_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_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(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_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(tag_gate_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_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(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_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(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_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(tag_gate_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_gate_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_gate_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tag_gate_sptr self) -> float"""
        return _blocks_swig6.tag_gate_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tag_gate_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tag_gate_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tag_gate_sptr self)"""
        return _blocks_swig6.tag_gate_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tag_gate_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tag_gate_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tag_gate_sptr self) -> int"""
        return _blocks_swig6.tag_gate_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tag_gate_sptr self) -> int"""
        return _blocks_swig6.tag_gate_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tag_gate_sptr self, int priority) -> int"""
        return _blocks_swig6.tag_gate_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tag_gate_sptr self) -> std::string"""
        return _blocks_swig6.tag_gate_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tag_gate_sptr self) -> std::string"""
        return _blocks_swig6.tag_gate_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tag_gate_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tag_gate_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tag_gate_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tag_gate_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tag_gate_sptr self) -> long"""
        return _blocks_swig6.tag_gate_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tag_gate_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tag_gate_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tag_gate_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tag_gate_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tag_gate_sptr self) -> std::string"""
        return _blocks_swig6.tag_gate_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tag_gate_sptr self, std::string name)"""
        return _blocks_swig6.tag_gate_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tag_gate_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tag_gate_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tag_gate_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_gate_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tag_gate_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_gate_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tag_gate_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_gate_sptr_message_subscribers(self, which_port)

# Register tag_gate_sptr in _blocks_swig6:
_blocks_swig6.tag_gate_sptr_swigregister(tag_gate_sptr)


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

class tag_share_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tag_share > 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__(tag_share_sptr self) -> tag_share_sptr
        __init__(tag_share_sptr self, tag_share p) -> tag_share_sptr
        """
        _blocks_swig6.tag_share_sptr_swiginit(self, _blocks_swig6.new_tag_share_sptr(*args))

    def __deref__(self) -> "gr::blocks::tag_share *":
        r"""__deref__(tag_share_sptr self) -> tag_share"""
        return _blocks_swig6.tag_share_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tag_share_sptr

    def make(self, sizeof_io_item: "size_t", sizeof_share_item: "size_t", vlen: "size_t"=1) -> "gr::blocks::tag_share::sptr":
        r"""make(tag_share_sptr self, size_t sizeof_io_item, size_t sizeof_share_item, size_t vlen=1) -> tag_share_sptr"""
        return _blocks_swig6.tag_share_sptr_make(self, sizeof_io_item, sizeof_share_item, vlen)

    def history(self) -> "unsigned int":
        r"""history(tag_share_sptr self) -> unsigned int"""
        return _blocks_swig6.tag_share_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tag_share_sptr self, int which, int delay)
        declare_sample_delay(tag_share_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tag_share_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tag_share_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tag_share_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tag_share_sptr self, int multiple)"""
        return _blocks_swig6.tag_share_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tag_share_sptr self) -> int"""
        return _blocks_swig6.tag_share_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tag_share_sptr self) -> double"""
        return _blocks_swig6.tag_share_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tag_share_sptr self) -> uint64_t"""
        return _blocks_swig6.tag_share_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tag_share_sptr self) -> uint64_t"""
        return _blocks_swig6.tag_share_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tag_share_sptr self) -> bool"""
        return _blocks_swig6.tag_share_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tag_share_sptr self) -> bool"""
        return _blocks_swig6.tag_share_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tag_share_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tag_share_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tag_share_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tag_share_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tag_share_sptr self, std::string level)"""
        return _blocks_swig6.tag_share_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tag_share_sptr self) -> std::string"""
        return _blocks_swig6.tag_share_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tag_share_sptr self) -> int"""
        return _blocks_swig6.tag_share_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tag_share_sptr self, int m)"""
        return _blocks_swig6.tag_share_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tag_share_sptr self)"""
        return _blocks_swig6.tag_share_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tag_share_sptr self) -> bool"""
        return _blocks_swig6.tag_share_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tag_share_sptr self, int m)"""
        return _blocks_swig6.tag_share_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tag_share_sptr self) -> int"""
        return _blocks_swig6.tag_share_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tag_share_sptr self, int i) -> long"""
        return _blocks_swig6.tag_share_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tag_share_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_share_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tag_share_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tag_share_sptr self, int i) -> long"""
        return _blocks_swig6.tag_share_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tag_share_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_share_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tag_share_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tag_share_sptr self, int which) -> float
        pc_input_buffers_full(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_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(tag_share_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_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(tag_share_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_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(tag_share_sptr self, int which) -> float
        pc_output_buffers_full(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_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(tag_share_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_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(tag_share_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_share_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tag_share_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tag_share_sptr self) -> float"""
        return _blocks_swig6.tag_share_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tag_share_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tag_share_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tag_share_sptr self)"""
        return _blocks_swig6.tag_share_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tag_share_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tag_share_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tag_share_sptr self) -> int"""
        return _blocks_swig6.tag_share_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tag_share_sptr self) -> int"""
        return _blocks_swig6.tag_share_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tag_share_sptr self, int priority) -> int"""
        return _blocks_swig6.tag_share_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tag_share_sptr self) -> std::string"""
        return _blocks_swig6.tag_share_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tag_share_sptr self) -> std::string"""
        return _blocks_swig6.tag_share_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tag_share_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tag_share_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tag_share_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tag_share_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tag_share_sptr self) -> long"""
        return _blocks_swig6.tag_share_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tag_share_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tag_share_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tag_share_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tag_share_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tag_share_sptr self) -> std::string"""
        return _blocks_swig6.tag_share_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tag_share_sptr self, std::string name)"""
        return _blocks_swig6.tag_share_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tag_share_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tag_share_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tag_share_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_share_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tag_share_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_share_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tag_share_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tag_share_sptr_message_subscribers(self, which_port)

# Register tag_share_sptr in _blocks_swig6:
_blocks_swig6.tag_share_sptr_swigregister(tag_share_sptr)


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

class tagged_stream_align_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tagged_stream_align > 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__(tagged_stream_align_sptr self) -> tagged_stream_align_sptr
        __init__(tagged_stream_align_sptr self, tagged_stream_align p) -> tagged_stream_align_sptr
        """
        _blocks_swig6.tagged_stream_align_sptr_swiginit(self, _blocks_swig6.new_tagged_stream_align_sptr(*args))

    def __deref__(self) -> "gr::blocks::tagged_stream_align *":
        r"""__deref__(tagged_stream_align_sptr self) -> tagged_stream_align"""
        return _blocks_swig6.tagged_stream_align_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tagged_stream_align_sptr

    def make(self, itemsize: "size_t", lengthtagname: "std::string const &") -> "gr::blocks::tagged_stream_align::sptr":
        r"""make(tagged_stream_align_sptr self, size_t itemsize, std::string const & lengthtagname) -> tagged_stream_align_sptr"""
        return _blocks_swig6.tagged_stream_align_sptr_make(self, itemsize, lengthtagname)

    def history(self) -> "unsigned int":
        r"""history(tagged_stream_align_sptr self) -> unsigned int"""
        return _blocks_swig6.tagged_stream_align_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_stream_align_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_align_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tagged_stream_align_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_stream_align_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tagged_stream_align_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_stream_align_sptr self, int multiple)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_stream_align_sptr self) -> double"""
        return _blocks_swig6.tagged_stream_align_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_stream_align_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_align_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_stream_align_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_align_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_align_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_align_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_stream_align_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tagged_stream_align_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_stream_align_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tagged_stream_align_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_stream_align_sptr self, std::string level)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_align_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_stream_align_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_stream_align_sptr self)"""
        return _blocks_swig6.tagged_stream_align_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_stream_align_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_align_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_stream_align_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_stream_align_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_align_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_stream_align_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_align_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tagged_stream_align_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_stream_align_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_align_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_stream_align_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_align_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tagged_stream_align_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_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(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_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(tagged_stream_align_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_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(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_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(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_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(tagged_stream_align_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_align_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_align_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_stream_align_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_align_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_stream_align_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_stream_align_sptr self)"""
        return _blocks_swig6.tagged_stream_align_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_stream_align_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tagged_stream_align_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_stream_align_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_stream_align_sptr self, int priority) -> int"""
        return _blocks_swig6.tagged_stream_align_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_align_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_align_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_stream_align_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_align_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_stream_align_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_align_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_stream_align_sptr self) -> long"""
        return _blocks_swig6.tagged_stream_align_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_stream_align_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tagged_stream_align_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_stream_align_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tagged_stream_align_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_stream_align_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_align_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_stream_align_sptr self, std::string name)"""
        return _blocks_swig6.tagged_stream_align_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_stream_align_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tagged_stream_align_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_stream_align_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_align_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_stream_align_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_align_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_stream_align_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_align_sptr_message_subscribers(self, which_port)

# Register tagged_stream_align_sptr in _blocks_swig6:
_blocks_swig6.tagged_stream_align_sptr_swigregister(tagged_stream_align_sptr)


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

class tagged_stream_mux_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tagged_stream_mux > 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__(tagged_stream_mux_sptr self) -> tagged_stream_mux_sptr
        __init__(tagged_stream_mux_sptr self, tagged_stream_mux p) -> tagged_stream_mux_sptr
        """
        _blocks_swig6.tagged_stream_mux_sptr_swiginit(self, _blocks_swig6.new_tagged_stream_mux_sptr(*args))

    def __deref__(self) -> "gr::blocks::tagged_stream_mux *":
        r"""__deref__(tagged_stream_mux_sptr self) -> tagged_stream_mux"""
        return _blocks_swig6.tagged_stream_mux_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tagged_stream_mux_sptr

    def make(self, itemsize: "size_t", lengthtagname: "std::string const &", tag_preserve_head_pos: "unsigned int"=0) -> "gr::blocks::tagged_stream_mux::sptr":
        r"""make(tagged_stream_mux_sptr self, size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) -> tagged_stream_mux_sptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_make(self, itemsize, lengthtagname, tag_preserve_head_pos)

    def history(self) -> "unsigned int":
        r"""history(tagged_stream_mux_sptr self) -> unsigned int"""
        return _blocks_swig6.tagged_stream_mux_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_stream_mux_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_mux_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tagged_stream_mux_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_stream_mux_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tagged_stream_mux_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_stream_mux_sptr self, int multiple)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_stream_mux_sptr self) -> double"""
        return _blocks_swig6.tagged_stream_mux_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_stream_mux_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_mux_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_stream_mux_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_mux_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_mux_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_mux_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_stream_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tagged_stream_mux_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_stream_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tagged_stream_mux_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_stream_mux_sptr self, std::string level)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_mux_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_stream_mux_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_stream_mux_sptr self)"""
        return _blocks_swig6.tagged_stream_mux_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_stream_mux_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_mux_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_stream_mux_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_stream_mux_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_mux_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_stream_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_mux_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tagged_stream_mux_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_stream_mux_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_mux_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_stream_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_mux_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tagged_stream_mux_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_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(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_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(tagged_stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_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(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_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(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_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(tagged_stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_mux_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_stream_mux_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_mux_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_stream_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_stream_mux_sptr self)"""
        return _blocks_swig6.tagged_stream_mux_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_stream_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tagged_stream_mux_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_stream_mux_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_stream_mux_sptr self, int priority) -> int"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_mux_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_mux_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_stream_mux_sptr self) -> long"""
        return _blocks_swig6.tagged_stream_mux_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_stream_mux_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_stream_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tagged_stream_mux_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_stream_mux_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_mux_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_stream_mux_sptr self, std::string name)"""
        return _blocks_swig6.tagged_stream_mux_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_stream_mux_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tagged_stream_mux_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_stream_mux_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_stream_mux_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_stream_mux_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_mux_sptr_message_subscribers(self, which_port)

# Register tagged_stream_mux_sptr in _blocks_swig6:
_blocks_swig6.tagged_stream_mux_sptr_swigregister(tagged_stream_mux_sptr)


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

class tagged_stream_multiply_length_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tagged_stream_multiply_length > 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__(tagged_stream_multiply_length_sptr self) -> tagged_stream_multiply_length_sptr
        __init__(tagged_stream_multiply_length_sptr self, tagged_stream_multiply_length p) -> tagged_stream_multiply_length_sptr
        """
        _blocks_swig6.tagged_stream_multiply_length_sptr_swiginit(self, _blocks_swig6.new_tagged_stream_multiply_length_sptr(*args))

    def __deref__(self) -> "gr::blocks::tagged_stream_multiply_length *":
        r"""__deref__(tagged_stream_multiply_length_sptr self) -> tagged_stream_multiply_length"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tagged_stream_multiply_length_sptr

    def set_scalar(self, scalar: "double") -> "void":
        r"""set_scalar(tagged_stream_multiply_length_sptr self, double scalar)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_scalar(self, scalar)

    def make(self, itemsize: "size_t", lengthtagname: "std::string const &", scalar: "double") -> "gr::blocks::tagged_stream_multiply_length::sptr":
        r"""make(tagged_stream_multiply_length_sptr self, size_t itemsize, std::string const & lengthtagname, double scalar) -> tagged_stream_multiply_length_sptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_make(self, itemsize, lengthtagname, scalar)

    def history(self) -> "unsigned int":
        r"""history(tagged_stream_multiply_length_sptr self) -> unsigned int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_stream_multiply_length_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_multiply_length_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tagged_stream_multiply_length_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_stream_multiply_length_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_stream_multiply_length_sptr self, int multiple)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_stream_multiply_length_sptr self) -> double"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_stream_multiply_length_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_stream_multiply_length_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_stream_multiply_length_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_stream_multiply_length_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_stream_multiply_length_sptr self, std::string level)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_stream_multiply_length_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_stream_multiply_length_sptr self)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_stream_multiply_length_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_stream_multiply_length_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_stream_multiply_length_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_stream_multiply_length_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_multiply_length_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_stream_multiply_length_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_stream_multiply_length_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_multiply_length_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_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(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_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(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_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(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_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(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_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(tagged_stream_multiply_length_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_multiply_length_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_stream_multiply_length_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_stream_multiply_length_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_stream_multiply_length_sptr self)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_stream_multiply_length_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_stream_multiply_length_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_stream_multiply_length_sptr self, int priority) -> int"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_stream_multiply_length_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_stream_multiply_length_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_stream_multiply_length_sptr self) -> long"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_stream_multiply_length_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_stream_multiply_length_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_stream_multiply_length_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_stream_multiply_length_sptr self, std::string name)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_stream_multiply_length_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_stream_multiply_length_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_stream_multiply_length_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_stream_multiply_length_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_multiply_length_sptr_message_subscribers(self, which_port)

# Register tagged_stream_multiply_length_sptr in _blocks_swig6:
_blocks_swig6.tagged_stream_multiply_length_sptr_swigregister(tagged_stream_multiply_length_sptr)


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

class tagged_stream_to_pdu_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tagged_stream_to_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__(tagged_stream_to_pdu_sptr self) -> tagged_stream_to_pdu_sptr
        __init__(tagged_stream_to_pdu_sptr self, tagged_stream_to_pdu p) -> tagged_stream_to_pdu_sptr
        """
        _blocks_swig6.tagged_stream_to_pdu_sptr_swiginit(self, _blocks_swig6.new_tagged_stream_to_pdu_sptr(*args))

    def __deref__(self) -> "gr::blocks::tagged_stream_to_pdu *":
        r"""__deref__(tagged_stream_to_pdu_sptr self) -> tagged_stream_to_pdu"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tagged_stream_to_pdu_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::tagged_stream_to_pdu::sptr":
        r"""make(tagged_stream_to_pdu_sptr self, gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") -> tagged_stream_to_pdu_sptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tagged_stream_to_pdu_sptr self) -> unsigned int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_stream_to_pdu_sptr self, int which, int delay)
        declare_sample_delay(tagged_stream_to_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tagged_stream_to_pdu_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_stream_to_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_stream_to_pdu_sptr self, int multiple)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_stream_to_pdu_sptr self) -> double"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_stream_to_pdu_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_stream_to_pdu_sptr self) -> uint64_t"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_stream_to_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_stream_to_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_stream_to_pdu_sptr self, std::string level)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_stream_to_pdu_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_stream_to_pdu_sptr self)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_stream_to_pdu_sptr self) -> bool"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_stream_to_pdu_sptr self, int m)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_stream_to_pdu_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_stream_to_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_stream_to_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_stream_to_pdu_sptr self, int i) -> long"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_stream_to_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_stream_to_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_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(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_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(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_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(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_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(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_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(tagged_stream_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_stream_to_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_stream_to_pdu_sptr self) -> float"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_stream_to_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_stream_to_pdu_sptr self)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_stream_to_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_stream_to_pdu_sptr self) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_stream_to_pdu_sptr self, int priority) -> int"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_stream_to_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_stream_to_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_stream_to_pdu_sptr self) -> long"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_stream_to_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_stream_to_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_stream_to_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_stream_to_pdu_sptr self, std::string name)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_stream_to_pdu_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_stream_to_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_stream_to_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_stream_to_pdu_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tagged_stream_to_pdu_sptr_message_subscribers(self, which_port)

# Register tagged_stream_to_pdu_sptr in _blocks_swig6:
_blocks_swig6.tagged_stream_to_pdu_sptr_swigregister(tagged_stream_to_pdu_sptr)


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

class tags_strobe_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tags_strobe > 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__(tags_strobe_sptr self) -> tags_strobe_sptr
        __init__(tags_strobe_sptr self, tags_strobe p) -> tags_strobe_sptr
        """
        _blocks_swig6.tags_strobe_sptr_swiginit(self, _blocks_swig6.new_tags_strobe_sptr(*args))

    def __deref__(self) -> "gr::blocks::tags_strobe *":
        r"""__deref__(tags_strobe_sptr self) -> tags_strobe"""
        return _blocks_swig6.tags_strobe_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tags_strobe_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::tags_strobe::sptr":
        r"""make(tags_strobe_sptr self, size_t sizeof_stream_item, swig_pmt_ptr value, uint64_t nsamps, swig_pmt_ptr key=pmt::intern("strobe")) -> tags_strobe_sptr"""
        return _blocks_swig6.tags_strobe_sptr_make(self, *args, **kwargs)

    def set_value(self, value: "swig_pmt_ptr") -> "void":
        r"""set_value(tags_strobe_sptr self, swig_pmt_ptr value)"""
        return _blocks_swig6.tags_strobe_sptr_set_value(self, value)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(tags_strobe_sptr self, swig_pmt_ptr key)"""
        return _blocks_swig6.tags_strobe_sptr_set_key(self, key)

    def value(self) -> "pmt::pmt_t":
        r"""value(tags_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_sptr_value(self)

    def key(self) -> "pmt::pmt_t":
        r"""key(tags_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_sptr_key(self)

    def set_nsamps(self, nsamps: "uint64_t") -> "void":
        r"""set_nsamps(tags_strobe_sptr self, uint64_t nsamps)"""
        return _blocks_swig6.tags_strobe_sptr_set_nsamps(self, nsamps)

    def nsamps(self) -> "uint64_t":
        r"""nsamps(tags_strobe_sptr self) -> uint64_t"""
        return _blocks_swig6.tags_strobe_sptr_nsamps(self)

    def history(self) -> "unsigned int":
        r"""history(tags_strobe_sptr self) -> unsigned int"""
        return _blocks_swig6.tags_strobe_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tags_strobe_sptr self, int which, int delay)
        declare_sample_delay(tags_strobe_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tags_strobe_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tags_strobe_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tags_strobe_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tags_strobe_sptr self, int multiple)"""
        return _blocks_swig6.tags_strobe_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tags_strobe_sptr self) -> int"""
        return _blocks_swig6.tags_strobe_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tags_strobe_sptr self) -> double"""
        return _blocks_swig6.tags_strobe_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tags_strobe_sptr self) -> uint64_t"""
        return _blocks_swig6.tags_strobe_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tags_strobe_sptr self) -> uint64_t"""
        return _blocks_swig6.tags_strobe_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tags_strobe_sptr self) -> bool"""
        return _blocks_swig6.tags_strobe_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tags_strobe_sptr self) -> bool"""
        return _blocks_swig6.tags_strobe_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tags_strobe_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tags_strobe_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tags_strobe_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tags_strobe_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tags_strobe_sptr self, std::string level)"""
        return _blocks_swig6.tags_strobe_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig6.tags_strobe_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tags_strobe_sptr self) -> int"""
        return _blocks_swig6.tags_strobe_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tags_strobe_sptr self, int m)"""
        return _blocks_swig6.tags_strobe_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tags_strobe_sptr self)"""
        return _blocks_swig6.tags_strobe_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tags_strobe_sptr self) -> bool"""
        return _blocks_swig6.tags_strobe_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tags_strobe_sptr self, int m)"""
        return _blocks_swig6.tags_strobe_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tags_strobe_sptr self) -> int"""
        return _blocks_swig6.tags_strobe_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tags_strobe_sptr self, int i) -> long"""
        return _blocks_swig6.tags_strobe_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tags_strobe_sptr self, long max_output_buffer)
        set_max_output_buffer(tags_strobe_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tags_strobe_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tags_strobe_sptr self, int i) -> long"""
        return _blocks_swig6.tags_strobe_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tags_strobe_sptr self, long min_output_buffer)
        set_min_output_buffer(tags_strobe_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tags_strobe_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_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(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_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(tags_strobe_sptr self, int which) -> float
        pc_input_buffers_full_var(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_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(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_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(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_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(tags_strobe_sptr self, int which) -> float
        pc_output_buffers_full_var(tags_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tags_strobe_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tags_strobe_sptr self) -> float"""
        return _blocks_swig6.tags_strobe_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tags_strobe_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tags_strobe_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tags_strobe_sptr self)"""
        return _blocks_swig6.tags_strobe_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tags_strobe_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tags_strobe_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tags_strobe_sptr self) -> int"""
        return _blocks_swig6.tags_strobe_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tags_strobe_sptr self) -> int"""
        return _blocks_swig6.tags_strobe_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tags_strobe_sptr self, int priority) -> int"""
        return _blocks_swig6.tags_strobe_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig6.tags_strobe_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig6.tags_strobe_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tags_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tags_strobe_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tags_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tags_strobe_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tags_strobe_sptr self) -> long"""
        return _blocks_swig6.tags_strobe_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tags_strobe_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tags_strobe_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tags_strobe_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tags_strobe_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tags_strobe_sptr self) -> std::string"""
        return _blocks_swig6.tags_strobe_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tags_strobe_sptr self, std::string name)"""
        return _blocks_swig6.tags_strobe_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tags_strobe_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tags_strobe_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tags_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tags_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tags_strobe_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tags_strobe_sptr_message_subscribers(self, which_port)

# Register tags_strobe_sptr in _blocks_swig6:
_blocks_swig6.tags_strobe_sptr_swigregister(tags_strobe_sptr)


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

class tcp_server_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tcp_server_sink > 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__(tcp_server_sink_sptr self) -> tcp_server_sink_sptr
        __init__(tcp_server_sink_sptr self, tcp_server_sink p) -> tcp_server_sink_sptr
        """
        _blocks_swig6.tcp_server_sink_sptr_swiginit(self, _blocks_swig6.new_tcp_server_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::tcp_server_sink *":
        r"""__deref__(tcp_server_sink_sptr self) -> tcp_server_sink"""
        return _blocks_swig6.tcp_server_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tcp_server_sink_sptr

    def make(self, itemsize: "size_t", host: "std::string const &", port: "int", noblock: "bool"=False) -> "gr::blocks::tcp_server_sink::sptr":
        r"""make(tcp_server_sink_sptr self, size_t itemsize, std::string const & host, int port, bool noblock=False) -> tcp_server_sink_sptr"""
        return _blocks_swig6.tcp_server_sink_sptr_make(self, itemsize, host, port, noblock)

    def history(self) -> "unsigned int":
        r"""history(tcp_server_sink_sptr self) -> unsigned int"""
        return _blocks_swig6.tcp_server_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tcp_server_sink_sptr self, int which, int delay)
        declare_sample_delay(tcp_server_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tcp_server_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tcp_server_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tcp_server_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tcp_server_sink_sptr self, int multiple)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tcp_server_sink_sptr self) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tcp_server_sink_sptr self) -> double"""
        return _blocks_swig6.tcp_server_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tcp_server_sink_sptr self) -> uint64_t"""
        return _blocks_swig6.tcp_server_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tcp_server_sink_sptr self) -> uint64_t"""
        return _blocks_swig6.tcp_server_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tcp_server_sink_sptr self) -> bool"""
        return _blocks_swig6.tcp_server_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tcp_server_sink_sptr self) -> bool"""
        return _blocks_swig6.tcp_server_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tcp_server_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tcp_server_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tcp_server_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tcp_server_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tcp_server_sink_sptr self, std::string level)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tcp_server_sink_sptr self) -> std::string"""
        return _blocks_swig6.tcp_server_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tcp_server_sink_sptr self) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tcp_server_sink_sptr self, int m)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tcp_server_sink_sptr self)"""
        return _blocks_swig6.tcp_server_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tcp_server_sink_sptr self) -> bool"""
        return _blocks_swig6.tcp_server_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tcp_server_sink_sptr self, int m)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tcp_server_sink_sptr self) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tcp_server_sink_sptr self, int i) -> long"""
        return _blocks_swig6.tcp_server_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tcp_server_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(tcp_server_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tcp_server_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tcp_server_sink_sptr self, int i) -> long"""
        return _blocks_swig6.tcp_server_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tcp_server_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(tcp_server_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tcp_server_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tcp_server_sink_sptr self, int which) -> float
        pc_input_buffers_full(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_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(tcp_server_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_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(tcp_server_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_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(tcp_server_sink_sptr self, int which) -> float
        pc_output_buffers_full(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_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(tcp_server_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_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(tcp_server_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(tcp_server_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tcp_server_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tcp_server_sink_sptr self) -> float"""
        return _blocks_swig6.tcp_server_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tcp_server_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tcp_server_sink_sptr self)"""
        return _blocks_swig6.tcp_server_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tcp_server_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tcp_server_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tcp_server_sink_sptr self) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tcp_server_sink_sptr self) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tcp_server_sink_sptr self, int priority) -> int"""
        return _blocks_swig6.tcp_server_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tcp_server_sink_sptr self) -> std::string"""
        return _blocks_swig6.tcp_server_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tcp_server_sink_sptr self) -> std::string"""
        return _blocks_swig6.tcp_server_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tcp_server_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tcp_server_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tcp_server_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tcp_server_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tcp_server_sink_sptr self) -> long"""
        return _blocks_swig6.tcp_server_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tcp_server_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tcp_server_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tcp_server_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tcp_server_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tcp_server_sink_sptr self) -> std::string"""
        return _blocks_swig6.tcp_server_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tcp_server_sink_sptr self, std::string name)"""
        return _blocks_swig6.tcp_server_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tcp_server_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tcp_server_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tcp_server_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tcp_server_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tcp_server_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tcp_server_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tcp_server_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tcp_server_sink_sptr_message_subscribers(self, which_port)

# Register tcp_server_sink_sptr in _blocks_swig6:
_blocks_swig6.tcp_server_sink_sptr_swigregister(tcp_server_sink_sptr)


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

class test_tag_variable_rate_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::test_tag_variable_rate_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__(test_tag_variable_rate_ff_sptr self) -> test_tag_variable_rate_ff_sptr
        __init__(test_tag_variable_rate_ff_sptr self, test_tag_variable_rate_ff p) -> test_tag_variable_rate_ff_sptr
        """
        _blocks_swig6.test_tag_variable_rate_ff_sptr_swiginit(self, _blocks_swig6.new_test_tag_variable_rate_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::test_tag_variable_rate_ff *":
        r"""__deref__(test_tag_variable_rate_ff_sptr self) -> test_tag_variable_rate_ff"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_test_tag_variable_rate_ff_sptr

    def make(self, update_once: "bool"=False, update_step: "double"=0.001) -> "gr::blocks::test_tag_variable_rate_ff::sptr":
        r"""make(test_tag_variable_rate_ff_sptr self, bool update_once=False, double update_step=0.001) -> test_tag_variable_rate_ff_sptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_make(self, update_once, update_step)

    def history(self) -> "unsigned int":
        r"""history(test_tag_variable_rate_ff_sptr self) -> unsigned int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(test_tag_variable_rate_ff_sptr self, int which, int delay)
        declare_sample_delay(test_tag_variable_rate_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(test_tag_variable_rate_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(test_tag_variable_rate_ff_sptr self, int multiple)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(test_tag_variable_rate_ff_sptr self) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(test_tag_variable_rate_ff_sptr self) -> double"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(test_tag_variable_rate_ff_sptr self) -> uint64_t"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(test_tag_variable_rate_ff_sptr self) -> uint64_t"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(test_tag_variable_rate_ff_sptr self) -> bool"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(test_tag_variable_rate_ff_sptr self) -> bool"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(test_tag_variable_rate_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(test_tag_variable_rate_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(test_tag_variable_rate_ff_sptr self, std::string level)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(test_tag_variable_rate_ff_sptr self) -> std::string"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(test_tag_variable_rate_ff_sptr self) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(test_tag_variable_rate_ff_sptr self, int m)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(test_tag_variable_rate_ff_sptr self)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(test_tag_variable_rate_ff_sptr self) -> bool"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(test_tag_variable_rate_ff_sptr self, int m)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(test_tag_variable_rate_ff_sptr self) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(test_tag_variable_rate_ff_sptr self, int i) -> long"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(test_tag_variable_rate_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(test_tag_variable_rate_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(test_tag_variable_rate_ff_sptr self, int i) -> long"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(test_tag_variable_rate_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(test_tag_variable_rate_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_input_buffers_full(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_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(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_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(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_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(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_output_buffers_full(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_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(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_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(test_tag_variable_rate_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(test_tag_variable_rate_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(test_tag_variable_rate_ff_sptr self) -> float"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(test_tag_variable_rate_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(test_tag_variable_rate_ff_sptr self)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(test_tag_variable_rate_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(test_tag_variable_rate_ff_sptr self) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(test_tag_variable_rate_ff_sptr self) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(test_tag_variable_rate_ff_sptr self, int priority) -> int"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(test_tag_variable_rate_ff_sptr self) -> std::string"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(test_tag_variable_rate_ff_sptr self) -> std::string"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(test_tag_variable_rate_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(test_tag_variable_rate_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(test_tag_variable_rate_ff_sptr self) -> long"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(test_tag_variable_rate_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(test_tag_variable_rate_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(test_tag_variable_rate_ff_sptr self) -> std::string"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(test_tag_variable_rate_ff_sptr self, std::string name)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(test_tag_variable_rate_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(test_tag_variable_rate_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(test_tag_variable_rate_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(test_tag_variable_rate_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.test_tag_variable_rate_ff_sptr_message_subscribers(self, which_port)

# Register test_tag_variable_rate_ff_sptr in _blocks_swig6:
_blocks_swig6.test_tag_variable_rate_ff_sptr_swigregister(test_tag_variable_rate_ff_sptr)


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

class threshold_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::threshold_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__(threshold_ff_sptr self) -> threshold_ff_sptr
        __init__(threshold_ff_sptr self, threshold_ff p) -> threshold_ff_sptr
        """
        _blocks_swig6.threshold_ff_sptr_swiginit(self, _blocks_swig6.new_threshold_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::threshold_ff *":
        r"""__deref__(threshold_ff_sptr self) -> threshold_ff"""
        return _blocks_swig6.threshold_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_threshold_ff_sptr

    def make(self, lo: "float", hi: "float", initial_state: "float"=0) -> "gr::blocks::threshold_ff::sptr":
        r"""make(threshold_ff_sptr self, float lo, float hi, float initial_state=0) -> threshold_ff_sptr"""
        return _blocks_swig6.threshold_ff_sptr_make(self, lo, hi, initial_state)

    def lo(self) -> "float":
        r"""lo(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_lo(self)

    def set_lo(self, lo: "float") -> "void":
        r"""set_lo(threshold_ff_sptr self, float lo)"""
        return _blocks_swig6.threshold_ff_sptr_set_lo(self, lo)

    def hi(self) -> "float":
        r"""hi(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_hi(self)

    def set_hi(self, hi: "float") -> "void":
        r"""set_hi(threshold_ff_sptr self, float hi)"""
        return _blocks_swig6.threshold_ff_sptr_set_hi(self, hi)

    def last_state(self) -> "float":
        r"""last_state(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_last_state(self)

    def set_last_state(self, last_state: "float") -> "void":
        r"""set_last_state(threshold_ff_sptr self, float last_state)"""
        return _blocks_swig6.threshold_ff_sptr_set_last_state(self, last_state)

    def history(self) -> "unsigned int":
        r"""history(threshold_ff_sptr self) -> unsigned int"""
        return _blocks_swig6.threshold_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(threshold_ff_sptr self, int which, int delay)
        declare_sample_delay(threshold_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig6.threshold_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(threshold_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.threshold_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(threshold_ff_sptr self, int multiple)"""
        return _blocks_swig6.threshold_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(threshold_ff_sptr self) -> int"""
        return _blocks_swig6.threshold_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(threshold_ff_sptr self) -> double"""
        return _blocks_swig6.threshold_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(threshold_ff_sptr self) -> uint64_t"""
        return _blocks_swig6.threshold_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(threshold_ff_sptr self) -> uint64_t"""
        return _blocks_swig6.threshold_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(threshold_ff_sptr self) -> bool"""
        return _blocks_swig6.threshold_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(threshold_ff_sptr self) -> bool"""
        return _blocks_swig6.threshold_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(threshold_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.threshold_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(threshold_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.threshold_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(threshold_ff_sptr self, std::string level)"""
        return _blocks_swig6.threshold_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig6.threshold_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(threshold_ff_sptr self) -> int"""
        return _blocks_swig6.threshold_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(threshold_ff_sptr self, int m)"""
        return _blocks_swig6.threshold_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(threshold_ff_sptr self)"""
        return _blocks_swig6.threshold_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(threshold_ff_sptr self) -> bool"""
        return _blocks_swig6.threshold_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(threshold_ff_sptr self, int m)"""
        return _blocks_swig6.threshold_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(threshold_ff_sptr self) -> int"""
        return _blocks_swig6.threshold_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(threshold_ff_sptr self, int i) -> long"""
        return _blocks_swig6.threshold_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(threshold_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(threshold_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.threshold_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(threshold_ff_sptr self, int i) -> long"""
        return _blocks_swig6.threshold_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(threshold_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(threshold_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.threshold_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_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(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_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(threshold_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_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(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_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(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_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(threshold_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(threshold_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.threshold_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(threshold_ff_sptr self) -> float"""
        return _blocks_swig6.threshold_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(threshold_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.threshold_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(threshold_ff_sptr self)"""
        return _blocks_swig6.threshold_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(threshold_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.threshold_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(threshold_ff_sptr self) -> int"""
        return _blocks_swig6.threshold_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(threshold_ff_sptr self) -> int"""
        return _blocks_swig6.threshold_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(threshold_ff_sptr self, int priority) -> int"""
        return _blocks_swig6.threshold_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig6.threshold_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig6.threshold_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(threshold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.threshold_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(threshold_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.threshold_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(threshold_ff_sptr self) -> long"""
        return _blocks_swig6.threshold_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(threshold_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.threshold_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(threshold_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.threshold_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(threshold_ff_sptr self) -> std::string"""
        return _blocks_swig6.threshold_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(threshold_ff_sptr self, std::string name)"""
        return _blocks_swig6.threshold_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(threshold_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.threshold_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(threshold_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.threshold_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(threshold_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.threshold_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(threshold_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.threshold_ff_sptr_message_subscribers(self, which_port)

# Register threshold_ff_sptr in _blocks_swig6:
_blocks_swig6.threshold_ff_sptr_swigregister(threshold_ff_sptr)


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

class transcendental_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::transcendental > 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__(transcendental_sptr self) -> transcendental_sptr
        __init__(transcendental_sptr self, transcendental p) -> transcendental_sptr
        """
        _blocks_swig6.transcendental_sptr_swiginit(self, _blocks_swig6.new_transcendental_sptr(*args))

    def __deref__(self) -> "gr::blocks::transcendental *":
        r"""__deref__(transcendental_sptr self) -> transcendental"""
        return _blocks_swig6.transcendental_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_transcendental_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::transcendental::sptr":
        r"""make(transcendental_sptr self, std::string const & name, std::string const & type="float") -> transcendental_sptr"""
        return _blocks_swig6.transcendental_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(transcendental_sptr self) -> unsigned int"""
        return _blocks_swig6.transcendental_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(transcendental_sptr self, int which, int delay)
        declare_sample_delay(transcendental_sptr self, unsigned int delay)
        """
        return _blocks_swig6.transcendental_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(transcendental_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.transcendental_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(transcendental_sptr self, int multiple)"""
        return _blocks_swig6.transcendental_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(transcendental_sptr self) -> int"""
        return _blocks_swig6.transcendental_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(transcendental_sptr self) -> double"""
        return _blocks_swig6.transcendental_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(transcendental_sptr self) -> uint64_t"""
        return _blocks_swig6.transcendental_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(transcendental_sptr self) -> uint64_t"""
        return _blocks_swig6.transcendental_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(transcendental_sptr self) -> bool"""
        return _blocks_swig6.transcendental_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(transcendental_sptr self) -> bool"""
        return _blocks_swig6.transcendental_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(transcendental_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.transcendental_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(transcendental_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.transcendental_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(transcendental_sptr self, std::string level)"""
        return _blocks_swig6.transcendental_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(transcendental_sptr self) -> std::string"""
        return _blocks_swig6.transcendental_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(transcendental_sptr self) -> int"""
        return _blocks_swig6.transcendental_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(transcendental_sptr self, int m)"""
        return _blocks_swig6.transcendental_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(transcendental_sptr self)"""
        return _blocks_swig6.transcendental_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(transcendental_sptr self) -> bool"""
        return _blocks_swig6.transcendental_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(transcendental_sptr self, int m)"""
        return _blocks_swig6.transcendental_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(transcendental_sptr self) -> int"""
        return _blocks_swig6.transcendental_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(transcendental_sptr self, int i) -> long"""
        return _blocks_swig6.transcendental_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(transcendental_sptr self, long max_output_buffer)
        set_max_output_buffer(transcendental_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.transcendental_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(transcendental_sptr self, int i) -> long"""
        return _blocks_swig6.transcendental_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(transcendental_sptr self, long min_output_buffer)
        set_min_output_buffer(transcendental_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.transcendental_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(transcendental_sptr self, int which) -> float
        pc_input_buffers_full(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_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(transcendental_sptr self, int which) -> float
        pc_input_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_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(transcendental_sptr self, int which) -> float
        pc_input_buffers_full_var(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_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(transcendental_sptr self, int which) -> float
        pc_output_buffers_full(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_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(transcendental_sptr self, int which) -> float
        pc_output_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_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(transcendental_sptr self, int which) -> float
        pc_output_buffers_full_var(transcendental_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.transcendental_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(transcendental_sptr self) -> float"""
        return _blocks_swig6.transcendental_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(transcendental_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.transcendental_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(transcendental_sptr self)"""
        return _blocks_swig6.transcendental_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(transcendental_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.transcendental_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(transcendental_sptr self) -> int"""
        return _blocks_swig6.transcendental_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(transcendental_sptr self) -> int"""
        return _blocks_swig6.transcendental_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(transcendental_sptr self, int priority) -> int"""
        return _blocks_swig6.transcendental_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(transcendental_sptr self) -> std::string"""
        return _blocks_swig6.transcendental_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(transcendental_sptr self) -> std::string"""
        return _blocks_swig6.transcendental_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(transcendental_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.transcendental_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(transcendental_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.transcendental_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(transcendental_sptr self) -> long"""
        return _blocks_swig6.transcendental_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(transcendental_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.transcendental_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(transcendental_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.transcendental_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(transcendental_sptr self) -> std::string"""
        return _blocks_swig6.transcendental_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(transcendental_sptr self, std::string name)"""
        return _blocks_swig6.transcendental_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(transcendental_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.transcendental_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(transcendental_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.transcendental_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(transcendental_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.transcendental_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(transcendental_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.transcendental_sptr_message_subscribers(self, which_port)

# Register transcendental_sptr in _blocks_swig6:
_blocks_swig6.transcendental_sptr_swigregister(transcendental_sptr)


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

class tuntap_pdu_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tuntap_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__(tuntap_pdu_sptr self) -> tuntap_pdu_sptr
        __init__(tuntap_pdu_sptr self, tuntap_pdu p) -> tuntap_pdu_sptr
        """
        _blocks_swig6.tuntap_pdu_sptr_swiginit(self, _blocks_swig6.new_tuntap_pdu_sptr(*args))

    def __deref__(self) -> "gr::blocks::tuntap_pdu *":
        r"""__deref__(tuntap_pdu_sptr self) -> tuntap_pdu"""
        return _blocks_swig6.tuntap_pdu_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_tuntap_pdu_sptr

    def make(self, dev: "std::string", MTU: "int"=10000, istunflag: "bool"=False) -> "gr::blocks::tuntap_pdu::sptr":
        r"""make(tuntap_pdu_sptr self, std::string dev, int MTU=10000, bool istunflag=False) -> tuntap_pdu_sptr"""
        return _blocks_swig6.tuntap_pdu_sptr_make(self, dev, MTU, istunflag)

    def history(self) -> "unsigned int":
        r"""history(tuntap_pdu_sptr self) -> unsigned int"""
        return _blocks_swig6.tuntap_pdu_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tuntap_pdu_sptr self, int which, int delay)
        declare_sample_delay(tuntap_pdu_sptr self, unsigned int delay)
        """
        return _blocks_swig6.tuntap_pdu_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tuntap_pdu_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.tuntap_pdu_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tuntap_pdu_sptr self, int multiple)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tuntap_pdu_sptr self) -> double"""
        return _blocks_swig6.tuntap_pdu_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tuntap_pdu_sptr self) -> uint64_t"""
        return _blocks_swig6.tuntap_pdu_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tuntap_pdu_sptr self) -> uint64_t"""
        return _blocks_swig6.tuntap_pdu_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig6.tuntap_pdu_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig6.tuntap_pdu_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tuntap_pdu_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.tuntap_pdu_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tuntap_pdu_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.tuntap_pdu_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tuntap_pdu_sptr self, std::string level)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tuntap_pdu_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tuntap_pdu_sptr self, int m)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tuntap_pdu_sptr self)"""
        return _blocks_swig6.tuntap_pdu_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tuntap_pdu_sptr self) -> bool"""
        return _blocks_swig6.tuntap_pdu_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tuntap_pdu_sptr self, int m)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tuntap_pdu_sptr self, int i) -> long"""
        return _blocks_swig6.tuntap_pdu_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tuntap_pdu_sptr self, long max_output_buffer)
        set_max_output_buffer(tuntap_pdu_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.tuntap_pdu_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tuntap_pdu_sptr self, int i) -> long"""
        return _blocks_swig6.tuntap_pdu_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tuntap_pdu_sptr self, long min_output_buffer)
        set_min_output_buffer(tuntap_pdu_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.tuntap_pdu_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_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(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_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(tuntap_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_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(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_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(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_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(tuntap_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(tuntap_pdu_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.tuntap_pdu_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tuntap_pdu_sptr self) -> float"""
        return _blocks_swig6.tuntap_pdu_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tuntap_pdu_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tuntap_pdu_sptr self)"""
        return _blocks_swig6.tuntap_pdu_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tuntap_pdu_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.tuntap_pdu_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tuntap_pdu_sptr self) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tuntap_pdu_sptr self, int priority) -> int"""
        return _blocks_swig6.tuntap_pdu_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tuntap_pdu_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tuntap_pdu_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tuntap_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tuntap_pdu_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tuntap_pdu_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.tuntap_pdu_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tuntap_pdu_sptr self) -> long"""
        return _blocks_swig6.tuntap_pdu_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tuntap_pdu_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.tuntap_pdu_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tuntap_pdu_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.tuntap_pdu_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tuntap_pdu_sptr self) -> std::string"""
        return _blocks_swig6.tuntap_pdu_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tuntap_pdu_sptr self, std::string name)"""
        return _blocks_swig6.tuntap_pdu_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tuntap_pdu_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.tuntap_pdu_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tuntap_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tuntap_pdu_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tuntap_pdu_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.tuntap_pdu_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tuntap_pdu_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.tuntap_pdu_sptr_message_subscribers(self, which_port)

# Register tuntap_pdu_sptr in _blocks_swig6:
_blocks_swig6.tuntap_pdu_sptr_swigregister(tuntap_pdu_sptr)


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

class uchar_to_float_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::uchar_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__(uchar_to_float_sptr self) -> uchar_to_float_sptr
        __init__(uchar_to_float_sptr self, uchar_to_float p) -> uchar_to_float_sptr
        """
        _blocks_swig6.uchar_to_float_sptr_swiginit(self, _blocks_swig6.new_uchar_to_float_sptr(*args))

    def __deref__(self) -> "gr::blocks::uchar_to_float *":
        r"""__deref__(uchar_to_float_sptr self) -> uchar_to_float"""
        return _blocks_swig6.uchar_to_float_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_uchar_to_float_sptr

    def make(self) -> "gr::blocks::uchar_to_float::sptr":
        r"""make(uchar_to_float_sptr self) -> uchar_to_float_sptr"""
        return _blocks_swig6.uchar_to_float_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(uchar_to_float_sptr self) -> unsigned int"""
        return _blocks_swig6.uchar_to_float_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(uchar_to_float_sptr self, int which, int delay)
        declare_sample_delay(uchar_to_float_sptr self, unsigned int delay)
        """
        return _blocks_swig6.uchar_to_float_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(uchar_to_float_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.uchar_to_float_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(uchar_to_float_sptr self, int multiple)"""
        return _blocks_swig6.uchar_to_float_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(uchar_to_float_sptr self) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(uchar_to_float_sptr self) -> double"""
        return _blocks_swig6.uchar_to_float_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(uchar_to_float_sptr self) -> uint64_t"""
        return _blocks_swig6.uchar_to_float_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(uchar_to_float_sptr self) -> uint64_t"""
        return _blocks_swig6.uchar_to_float_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig6.uchar_to_float_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig6.uchar_to_float_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(uchar_to_float_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.uchar_to_float_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(uchar_to_float_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.uchar_to_float_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(uchar_to_float_sptr self, std::string level)"""
        return _blocks_swig6.uchar_to_float_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig6.uchar_to_float_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(uchar_to_float_sptr self) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(uchar_to_float_sptr self, int m)"""
        return _blocks_swig6.uchar_to_float_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(uchar_to_float_sptr self)"""
        return _blocks_swig6.uchar_to_float_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(uchar_to_float_sptr self) -> bool"""
        return _blocks_swig6.uchar_to_float_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(uchar_to_float_sptr self, int m)"""
        return _blocks_swig6.uchar_to_float_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(uchar_to_float_sptr self) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(uchar_to_float_sptr self, int i) -> long"""
        return _blocks_swig6.uchar_to_float_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(uchar_to_float_sptr self, long max_output_buffer)
        set_max_output_buffer(uchar_to_float_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.uchar_to_float_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(uchar_to_float_sptr self, int i) -> long"""
        return _blocks_swig6.uchar_to_float_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(uchar_to_float_sptr self, long min_output_buffer)
        set_min_output_buffer(uchar_to_float_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.uchar_to_float_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_input_buffers_full_var(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, int which) -> float
        pc_output_buffers_full_var(uchar_to_float_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.uchar_to_float_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_to_float_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(uchar_to_float_sptr self) -> float"""
        return _blocks_swig6.uchar_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(uchar_to_float_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.uchar_to_float_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(uchar_to_float_sptr self)"""
        return _blocks_swig6.uchar_to_float_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(uchar_to_float_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.uchar_to_float_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(uchar_to_float_sptr self) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(uchar_to_float_sptr self) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(uchar_to_float_sptr self, int priority) -> int"""
        return _blocks_swig6.uchar_to_float_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig6.uchar_to_float_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig6.uchar_to_float_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(uchar_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.uchar_to_float_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(uchar_to_float_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.uchar_to_float_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(uchar_to_float_sptr self) -> long"""
        return _blocks_swig6.uchar_to_float_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(uchar_to_float_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.uchar_to_float_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(uchar_to_float_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.uchar_to_float_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(uchar_to_float_sptr self) -> std::string"""
        return _blocks_swig6.uchar_to_float_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(uchar_to_float_sptr self, std::string name)"""
        return _blocks_swig6.uchar_to_float_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(uchar_to_float_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.uchar_to_float_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(uchar_to_float_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.uchar_to_float_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(uchar_to_float_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.uchar_to_float_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(uchar_to_float_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.uchar_to_float_sptr_message_subscribers(self, which_port)

# Register uchar_to_float_sptr in _blocks_swig6:
_blocks_swig6.uchar_to_float_sptr_swigregister(uchar_to_float_sptr)


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

class udp_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::udp_sink > 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__(udp_sink_sptr self) -> udp_sink_sptr
        __init__(udp_sink_sptr self, udp_sink p) -> udp_sink_sptr
        """
        _blocks_swig6.udp_sink_sptr_swiginit(self, _blocks_swig6.new_udp_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::udp_sink *":
        r"""__deref__(udp_sink_sptr self) -> udp_sink"""
        return _blocks_swig6.udp_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_udp_sink_sptr

    def make(self, itemsize: "size_t", host: "std::string const &", port: "int", payload_size: "int"=1472, eof: "bool"=True) -> "gr::blocks::udp_sink::sptr":
        r"""make(udp_sink_sptr self, size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_sink_sptr"""
        return _blocks_swig6.udp_sink_sptr_make(self, itemsize, host, port, payload_size, eof)

    def payload_size(self) -> "int":
        r"""payload_size(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_payload_size(self)

    def connect(self, host: "std::string const &", port: "int") -> "void":
        r"""connect(udp_sink_sptr self, std::string const & host, int port)"""
        return _blocks_swig6.udp_sink_sptr_connect(self, host, port)

    def disconnect(self) -> "void":
        r"""disconnect(udp_sink_sptr self)"""
        return _blocks_swig6.udp_sink_sptr_disconnect(self)

    def history(self) -> "unsigned int":
        r"""history(udp_sink_sptr self) -> unsigned int"""
        return _blocks_swig6.udp_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(udp_sink_sptr self, int which, int delay)
        declare_sample_delay(udp_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig6.udp_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(udp_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.udp_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(udp_sink_sptr self, int multiple)"""
        return _blocks_swig6.udp_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(udp_sink_sptr self) -> double"""
        return _blocks_swig6.udp_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(udp_sink_sptr self) -> uint64_t"""
        return _blocks_swig6.udp_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(udp_sink_sptr self) -> uint64_t"""
        return _blocks_swig6.udp_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(udp_sink_sptr self) -> bool"""
        return _blocks_swig6.udp_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(udp_sink_sptr self) -> bool"""
        return _blocks_swig6.udp_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(udp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.udp_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(udp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.udp_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(udp_sink_sptr self, std::string level)"""
        return _blocks_swig6.udp_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(udp_sink_sptr self) -> std::string"""
        return _blocks_swig6.udp_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(udp_sink_sptr self, int m)"""
        return _blocks_swig6.udp_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(udp_sink_sptr self)"""
        return _blocks_swig6.udp_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(udp_sink_sptr self) -> bool"""
        return _blocks_swig6.udp_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(udp_sink_sptr self, int m)"""
        return _blocks_swig6.udp_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(udp_sink_sptr self, int i) -> long"""
        return _blocks_swig6.udp_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(udp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(udp_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.udp_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(udp_sink_sptr self, int i) -> long"""
        return _blocks_swig6.udp_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(udp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(udp_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.udp_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_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(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_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(udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_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(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_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(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_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(udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(udp_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(udp_sink_sptr self) -> float"""
        return _blocks_swig6.udp_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(udp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.udp_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(udp_sink_sptr self)"""
        return _blocks_swig6.udp_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(udp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.udp_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(udp_sink_sptr self) -> int"""
        return _blocks_swig6.udp_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(udp_sink_sptr self, int priority) -> int"""
        return _blocks_swig6.udp_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(udp_sink_sptr self) -> std::string"""
        return _blocks_swig6.udp_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(udp_sink_sptr self) -> std::string"""
        return _blocks_swig6.udp_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(udp_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.udp_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(udp_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.udp_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(udp_sink_sptr self) -> long"""
        return _blocks_swig6.udp_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(udp_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.udp_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(udp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.udp_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(udp_sink_sptr self) -> std::string"""
        return _blocks_swig6.udp_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(udp_sink_sptr self, std::string name)"""
        return _blocks_swig6.udp_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(udp_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.udp_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(udp_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(udp_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(udp_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_sink_sptr_message_subscribers(self, which_port)

# Register udp_sink_sptr in _blocks_swig6:
_blocks_swig6.udp_sink_sptr_swigregister(udp_sink_sptr)


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

class udp_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::udp_source > 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__(udp_source_sptr self) -> udp_source_sptr
        __init__(udp_source_sptr self, udp_source p) -> udp_source_sptr
        """
        _blocks_swig6.udp_source_sptr_swiginit(self, _blocks_swig6.new_udp_source_sptr(*args))

    def __deref__(self) -> "gr::blocks::udp_source *":
        r"""__deref__(udp_source_sptr self) -> udp_source"""
        return _blocks_swig6.udp_source_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_udp_source_sptr

    def make(self, itemsize: "size_t", host: "std::string const &", port: "int", payload_size: "int"=1472, eof: "bool"=True) -> "gr::blocks::udp_source::sptr":
        r"""make(udp_source_sptr self, size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) -> udp_source_sptr"""
        return _blocks_swig6.udp_source_sptr_make(self, itemsize, host, port, payload_size, eof)

    def connect(self, host: "std::string const &", port: "int") -> "void":
        r"""connect(udp_source_sptr self, std::string const & host, int port)"""
        return _blocks_swig6.udp_source_sptr_connect(self, host, port)

    def disconnect(self) -> "void":
        r"""disconnect(udp_source_sptr self)"""
        return _blocks_swig6.udp_source_sptr_disconnect(self)

    def payload_size(self) -> "int":
        r"""payload_size(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_payload_size(self)

    def get_port(self) -> "int":
        r"""get_port(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_get_port(self)

    def history(self) -> "unsigned int":
        r"""history(udp_source_sptr self) -> unsigned int"""
        return _blocks_swig6.udp_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(udp_source_sptr self, int which, int delay)
        declare_sample_delay(udp_source_sptr self, unsigned int delay)
        """
        return _blocks_swig6.udp_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(udp_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.udp_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(udp_source_sptr self, int multiple)"""
        return _blocks_swig6.udp_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(udp_source_sptr self) -> double"""
        return _blocks_swig6.udp_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(udp_source_sptr self) -> uint64_t"""
        return _blocks_swig6.udp_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(udp_source_sptr self) -> uint64_t"""
        return _blocks_swig6.udp_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(udp_source_sptr self) -> bool"""
        return _blocks_swig6.udp_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(udp_source_sptr self) -> bool"""
        return _blocks_swig6.udp_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(udp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.udp_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(udp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.udp_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(udp_source_sptr self, std::string level)"""
        return _blocks_swig6.udp_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(udp_source_sptr self) -> std::string"""
        return _blocks_swig6.udp_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(udp_source_sptr self, int m)"""
        return _blocks_swig6.udp_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(udp_source_sptr self)"""
        return _blocks_swig6.udp_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(udp_source_sptr self) -> bool"""
        return _blocks_swig6.udp_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(udp_source_sptr self, int m)"""
        return _blocks_swig6.udp_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(udp_source_sptr self, int i) -> long"""
        return _blocks_swig6.udp_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(udp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(udp_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.udp_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(udp_source_sptr self, int i) -> long"""
        return _blocks_swig6.udp_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(udp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(udp_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.udp_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(udp_source_sptr self, int which) -> float
        pc_input_buffers_full(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_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(udp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_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(udp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_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(udp_source_sptr self, int which) -> float
        pc_output_buffers_full(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_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(udp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_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(udp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(udp_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.udp_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(udp_source_sptr self) -> float"""
        return _blocks_swig6.udp_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(udp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.udp_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(udp_source_sptr self)"""
        return _blocks_swig6.udp_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(udp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.udp_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(udp_source_sptr self) -> int"""
        return _blocks_swig6.udp_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(udp_source_sptr self, int priority) -> int"""
        return _blocks_swig6.udp_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(udp_source_sptr self) -> std::string"""
        return _blocks_swig6.udp_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(udp_source_sptr self) -> std::string"""
        return _blocks_swig6.udp_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(udp_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.udp_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(udp_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.udp_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(udp_source_sptr self) -> long"""
        return _blocks_swig6.udp_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(udp_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.udp_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(udp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.udp_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(udp_source_sptr self) -> std::string"""
        return _blocks_swig6.udp_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(udp_source_sptr self, std::string name)"""
        return _blocks_swig6.udp_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(udp_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.udp_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(udp_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(udp_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(udp_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.udp_source_sptr_message_subscribers(self, which_port)

# Register udp_source_sptr in _blocks_swig6:
_blocks_swig6.udp_source_sptr_swigregister(udp_source_sptr)


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

class unpack_k_bits_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::unpack_k_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__(unpack_k_bits_bb_sptr self) -> unpack_k_bits_bb_sptr
        __init__(unpack_k_bits_bb_sptr self, unpack_k_bits_bb p) -> unpack_k_bits_bb_sptr
        """
        _blocks_swig6.unpack_k_bits_bb_sptr_swiginit(self, _blocks_swig6.new_unpack_k_bits_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::unpack_k_bits_bb *":
        r"""__deref__(unpack_k_bits_bb_sptr self) -> unpack_k_bits_bb"""
        return _blocks_swig6.unpack_k_bits_bb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_unpack_k_bits_bb_sptr

    def make(self, k: "unsigned int") -> "gr::blocks::unpack_k_bits_bb::sptr":
        r"""make(unpack_k_bits_bb_sptr self, unsigned int k) -> unpack_k_bits_bb_sptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_make(self, k)

    def history(self) -> "unsigned int":
        r"""history(unpack_k_bits_bb_sptr self) -> unsigned int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(unpack_k_bits_bb_sptr self, int which, int delay)
        declare_sample_delay(unpack_k_bits_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig6.unpack_k_bits_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(unpack_k_bits_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(unpack_k_bits_bb_sptr self, int multiple)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(unpack_k_bits_bb_sptr self) -> double"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(unpack_k_bits_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(unpack_k_bits_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(unpack_k_bits_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(unpack_k_bits_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(unpack_k_bits_bb_sptr self, std::string level)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(unpack_k_bits_bb_sptr self, int m)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(unpack_k_bits_bb_sptr self)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(unpack_k_bits_bb_sptr self) -> bool"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(unpack_k_bits_bb_sptr self, int m)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(unpack_k_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(unpack_k_bits_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(unpack_k_bits_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(unpack_k_bits_bb_sptr self, int i) -> long"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(unpack_k_bits_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(unpack_k_bits_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(unpack_k_bits_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(unpack_k_bits_bb_sptr self) -> float"""
        return _blocks_swig6.unpack_k_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(unpack_k_bits_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(unpack_k_bits_bb_sptr self)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(unpack_k_bits_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(unpack_k_bits_bb_sptr self) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(unpack_k_bits_bb_sptr self, int priority) -> int"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(unpack_k_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(unpack_k_bits_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(unpack_k_bits_bb_sptr self) -> long"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(unpack_k_bits_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(unpack_k_bits_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(unpack_k_bits_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(unpack_k_bits_bb_sptr self, std::string name)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(unpack_k_bits_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.unpack_k_bits_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(unpack_k_bits_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(unpack_k_bits_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(unpack_k_bits_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.unpack_k_bits_bb_sptr_message_subscribers(self, which_port)

# Register unpack_k_bits_bb_sptr in _blocks_swig6:
_blocks_swig6.unpack_k_bits_bb_sptr_swigregister(unpack_k_bits_bb_sptr)


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

class unpacked_to_packed_bb(object):
    r"""Proxy of C++ gr::blocks::unpacked_to_packed< 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(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< unsigned char >::sptr":
        r"""make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
        return _blocks_swig6.unpacked_to_packed_bb_make(bits_per_chunk, endianness)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_bb

# Register unpacked_to_packed_bb in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_bb_swigregister(unpacked_to_packed_bb)

def unpacked_to_packed_bb_make(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< unsigned char >::sptr":
    r"""unpacked_to_packed_bb_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
    return _blocks_swig6.unpacked_to_packed_bb_make(bits_per_chunk, endianness)

class unpacked_to_packed_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::unpacked_to_packed< 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__(unpacked_to_packed_bb_sptr self) -> unpacked_to_packed_bb_sptr
        __init__(unpacked_to_packed_bb_sptr self, unpacked_to_packed_bb p) -> unpacked_to_packed_bb_sptr
        """
        _blocks_swig6.unpacked_to_packed_bb_sptr_swiginit(self, _blocks_swig6.new_unpacked_to_packed_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::unpacked_to_packed< std::uint8_t > *":
        r"""__deref__(unpacked_to_packed_bb_sptr self) -> unpacked_to_packed_bb"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_bb_sptr

    def make(self, bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< unsigned char >::sptr":
        r"""make(unpacked_to_packed_bb_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_bb_sptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_make(self, bits_per_chunk, endianness)

    def history(self) -> "unsigned int":
        r"""history(unpacked_to_packed_bb_sptr self) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(unpacked_to_packed_bb_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig6.unpacked_to_packed_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(unpacked_to_packed_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(unpacked_to_packed_bb_sptr self, int multiple)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(unpacked_to_packed_bb_sptr self) -> double"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(unpacked_to_packed_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(unpacked_to_packed_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(unpacked_to_packed_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(unpacked_to_packed_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(unpacked_to_packed_bb_sptr self, std::string level)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(unpacked_to_packed_bb_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(unpacked_to_packed_bb_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(unpacked_to_packed_bb_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(unpacked_to_packed_bb_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(unpacked_to_packed_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(unpacked_to_packed_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(unpacked_to_packed_bb_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(unpacked_to_packed_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(unpacked_to_packed_bb_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(unpacked_to_packed_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(unpacked_to_packed_bb_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(unpacked_to_packed_bb_sptr self, int priority) -> int"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(unpacked_to_packed_bb_sptr self) -> long"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(unpacked_to_packed_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(unpacked_to_packed_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(unpacked_to_packed_bb_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(unpacked_to_packed_bb_sptr self, std::string name)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(unpacked_to_packed_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(unpacked_to_packed_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(unpacked_to_packed_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(unpacked_to_packed_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_bb_sptr_message_subscribers(self, which_port)

# Register unpacked_to_packed_bb_sptr in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_bb_sptr_swigregister(unpacked_to_packed_bb_sptr)


unpacked_to_packed_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
unpacked_to_packed_bb = unpacked_to_packed_bb.make

class unpacked_to_packed_ss(object):
    r"""Proxy of C++ gr::blocks::unpacked_to_packed< 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(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< short >::sptr":
        r"""make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
        return _blocks_swig6.unpacked_to_packed_ss_make(bits_per_chunk, endianness)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_ss

# Register unpacked_to_packed_ss in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_ss_swigregister(unpacked_to_packed_ss)

def unpacked_to_packed_ss_make(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< short >::sptr":
    r"""unpacked_to_packed_ss_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
    return _blocks_swig6.unpacked_to_packed_ss_make(bits_per_chunk, endianness)

class unpacked_to_packed_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::unpacked_to_packed< 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__(unpacked_to_packed_ss_sptr self) -> unpacked_to_packed_ss_sptr
        __init__(unpacked_to_packed_ss_sptr self, unpacked_to_packed_ss p) -> unpacked_to_packed_ss_sptr
        """
        _blocks_swig6.unpacked_to_packed_ss_sptr_swiginit(self, _blocks_swig6.new_unpacked_to_packed_ss_sptr(*args))

    def __deref__(self) -> "gr::blocks::unpacked_to_packed< std::int16_t > *":
        r"""__deref__(unpacked_to_packed_ss_sptr self) -> unpacked_to_packed_ss"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_ss_sptr

    def make(self, bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< short >::sptr":
        r"""make(unpacked_to_packed_ss_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ss_sptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_make(self, bits_per_chunk, endianness)

    def history(self) -> "unsigned int":
        r"""history(unpacked_to_packed_ss_sptr self) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(unpacked_to_packed_ss_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig6.unpacked_to_packed_ss_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(unpacked_to_packed_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(unpacked_to_packed_ss_sptr self, int multiple)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(unpacked_to_packed_ss_sptr self) -> double"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(unpacked_to_packed_ss_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(unpacked_to_packed_ss_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(unpacked_to_packed_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(unpacked_to_packed_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(unpacked_to_packed_ss_sptr self, std::string level)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(unpacked_to_packed_ss_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(unpacked_to_packed_ss_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(unpacked_to_packed_ss_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(unpacked_to_packed_ss_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(unpacked_to_packed_ss_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(unpacked_to_packed_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(unpacked_to_packed_ss_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(unpacked_to_packed_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(unpacked_to_packed_ss_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(unpacked_to_packed_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(unpacked_to_packed_ss_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(unpacked_to_packed_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(unpacked_to_packed_ss_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(unpacked_to_packed_ss_sptr self, int priority) -> int"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(unpacked_to_packed_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(unpacked_to_packed_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(unpacked_to_packed_ss_sptr self) -> long"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(unpacked_to_packed_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(unpacked_to_packed_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(unpacked_to_packed_ss_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(unpacked_to_packed_ss_sptr self, std::string name)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(unpacked_to_packed_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(unpacked_to_packed_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(unpacked_to_packed_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(unpacked_to_packed_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ss_sptr_message_subscribers(self, which_port)

# Register unpacked_to_packed_ss_sptr in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_ss_sptr_swigregister(unpacked_to_packed_ss_sptr)


unpacked_to_packed_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
unpacked_to_packed_ss = unpacked_to_packed_ss.make

class unpacked_to_packed_ii(object):
    r"""Proxy of C++ gr::blocks::unpacked_to_packed< 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(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< int >::sptr":
        r"""make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
        return _blocks_swig6.unpacked_to_packed_ii_make(bits_per_chunk, endianness)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_ii

# Register unpacked_to_packed_ii in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_ii_swigregister(unpacked_to_packed_ii)

def unpacked_to_packed_ii_make(bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< int >::sptr":
    r"""unpacked_to_packed_ii_make(unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
    return _blocks_swig6.unpacked_to_packed_ii_make(bits_per_chunk, endianness)

class unpacked_to_packed_ii_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::unpacked_to_packed< 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__(unpacked_to_packed_ii_sptr self) -> unpacked_to_packed_ii_sptr
        __init__(unpacked_to_packed_ii_sptr self, unpacked_to_packed_ii p) -> unpacked_to_packed_ii_sptr
        """
        _blocks_swig6.unpacked_to_packed_ii_sptr_swiginit(self, _blocks_swig6.new_unpacked_to_packed_ii_sptr(*args))

    def __deref__(self) -> "gr::blocks::unpacked_to_packed< std::int32_t > *":
        r"""__deref__(unpacked_to_packed_ii_sptr self) -> unpacked_to_packed_ii"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_unpacked_to_packed_ii_sptr

    def make(self, bits_per_chunk: "unsigned int", endianness: "gr::endianness_t") -> "gr::blocks::unpacked_to_packed< int >::sptr":
        r"""make(unpacked_to_packed_ii_sptr self, unsigned int bits_per_chunk, gr::endianness_t endianness) -> unpacked_to_packed_ii_sptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_make(self, bits_per_chunk, endianness)

    def history(self) -> "unsigned int":
        r"""history(unpacked_to_packed_ii_sptr self) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(unpacked_to_packed_ii_sptr self, int which, int delay)
        declare_sample_delay(unpacked_to_packed_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig6.unpacked_to_packed_ii_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(unpacked_to_packed_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(unpacked_to_packed_ii_sptr self, int multiple)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(unpacked_to_packed_ii_sptr self) -> double"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(unpacked_to_packed_ii_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(unpacked_to_packed_ii_sptr self) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(unpacked_to_packed_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(unpacked_to_packed_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(unpacked_to_packed_ii_sptr self, std::string level)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(unpacked_to_packed_ii_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(unpacked_to_packed_ii_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(unpacked_to_packed_ii_sptr self) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(unpacked_to_packed_ii_sptr self, int m)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(unpacked_to_packed_ii_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(unpacked_to_packed_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(unpacked_to_packed_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(unpacked_to_packed_ii_sptr self, int i) -> long"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(unpacked_to_packed_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(unpacked_to_packed_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_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(unpacked_to_packed_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(unpacked_to_packed_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(unpacked_to_packed_ii_sptr self) -> float"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(unpacked_to_packed_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(unpacked_to_packed_ii_sptr self)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(unpacked_to_packed_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(unpacked_to_packed_ii_sptr self) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(unpacked_to_packed_ii_sptr self, int priority) -> int"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(unpacked_to_packed_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(unpacked_to_packed_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(unpacked_to_packed_ii_sptr self) -> long"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(unpacked_to_packed_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(unpacked_to_packed_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(unpacked_to_packed_ii_sptr self) -> std::string"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(unpacked_to_packed_ii_sptr self, std::string name)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(unpacked_to_packed_ii_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(unpacked_to_packed_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(unpacked_to_packed_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(unpacked_to_packed_ii_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.unpacked_to_packed_ii_sptr_message_subscribers(self, which_port)

# Register unpacked_to_packed_ii_sptr in _blocks_swig6:
_blocks_swig6.unpacked_to_packed_ii_sptr_swigregister(unpacked_to_packed_ii_sptr)


unpacked_to_packed_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
unpacked_to_packed_ii = unpacked_to_packed_ii.make

class vco_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::vco_f > 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__(vco_f_sptr self) -> vco_f_sptr
        __init__(vco_f_sptr self, vco_f p) -> vco_f_sptr
        """
        _blocks_swig6.vco_f_sptr_swiginit(self, _blocks_swig6.new_vco_f_sptr(*args))

    def __deref__(self) -> "gr::blocks::vco_f *":
        r"""__deref__(vco_f_sptr self) -> vco_f"""
        return _blocks_swig6.vco_f_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_vco_f_sptr

    def make(self, sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_f::sptr":
        r"""make(vco_f_sptr self, double sampling_rate, double sensitivity, double amplitude) -> vco_f_sptr"""
        return _blocks_swig6.vco_f_sptr_make(self, sampling_rate, sensitivity, amplitude)

    def history(self) -> "unsigned int":
        r"""history(vco_f_sptr self) -> unsigned int"""
        return _blocks_swig6.vco_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(vco_f_sptr self, int which, int delay)
        declare_sample_delay(vco_f_sptr self, unsigned int delay)
        """
        return _blocks_swig6.vco_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(vco_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.vco_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(vco_f_sptr self, int multiple)"""
        return _blocks_swig6.vco_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(vco_f_sptr self) -> int"""
        return _blocks_swig6.vco_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(vco_f_sptr self) -> double"""
        return _blocks_swig6.vco_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(vco_f_sptr self) -> uint64_t"""
        return _blocks_swig6.vco_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(vco_f_sptr self) -> uint64_t"""
        return _blocks_swig6.vco_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(vco_f_sptr self) -> bool"""
        return _blocks_swig6.vco_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(vco_f_sptr self) -> bool"""
        return _blocks_swig6.vco_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(vco_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.vco_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(vco_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.vco_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(vco_f_sptr self, std::string level)"""
        return _blocks_swig6.vco_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(vco_f_sptr self) -> std::string"""
        return _blocks_swig6.vco_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(vco_f_sptr self) -> int"""
        return _blocks_swig6.vco_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(vco_f_sptr self, int m)"""
        return _blocks_swig6.vco_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(vco_f_sptr self)"""
        return _blocks_swig6.vco_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(vco_f_sptr self) -> bool"""
        return _blocks_swig6.vco_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(vco_f_sptr self, int m)"""
        return _blocks_swig6.vco_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(vco_f_sptr self) -> int"""
        return _blocks_swig6.vco_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(vco_f_sptr self, int i) -> long"""
        return _blocks_swig6.vco_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(vco_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vco_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.vco_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(vco_f_sptr self, int i) -> long"""
        return _blocks_swig6.vco_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(vco_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vco_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.vco_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(vco_f_sptr self, int which) -> float
        pc_input_buffers_full(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_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(vco_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_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(vco_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_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(vco_f_sptr self, int which) -> float
        pc_output_buffers_full(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_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(vco_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_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(vco_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vco_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(vco_f_sptr self) -> float"""
        return _blocks_swig6.vco_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(vco_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.vco_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(vco_f_sptr self)"""
        return _blocks_swig6.vco_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(vco_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.vco_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(vco_f_sptr self) -> int"""
        return _blocks_swig6.vco_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(vco_f_sptr self) -> int"""
        return _blocks_swig6.vco_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(vco_f_sptr self, int priority) -> int"""
        return _blocks_swig6.vco_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(vco_f_sptr self) -> std::string"""
        return _blocks_swig6.vco_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(vco_f_sptr self) -> std::string"""
        return _blocks_swig6.vco_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(vco_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.vco_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(vco_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.vco_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(vco_f_sptr self) -> long"""
        return _blocks_swig6.vco_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(vco_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.vco_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(vco_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.vco_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(vco_f_sptr self) -> std::string"""
        return _blocks_swig6.vco_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(vco_f_sptr self, std::string name)"""
        return _blocks_swig6.vco_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(vco_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.vco_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(vco_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(vco_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(vco_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_f_sptr_message_subscribers(self, which_port)

# Register vco_f_sptr in _blocks_swig6:
_blocks_swig6.vco_f_sptr_swigregister(vco_f_sptr)


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

class vco_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::vco_c > 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__(vco_c_sptr self) -> vco_c_sptr
        __init__(vco_c_sptr self, vco_c p) -> vco_c_sptr
        """
        _blocks_swig6.vco_c_sptr_swiginit(self, _blocks_swig6.new_vco_c_sptr(*args))

    def __deref__(self) -> "gr::blocks::vco_c *":
        r"""__deref__(vco_c_sptr self) -> vco_c"""
        return _blocks_swig6.vco_c_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_vco_c_sptr

    def make(self, sampling_rate: "double", sensitivity: "double", amplitude: "double") -> "gr::blocks::vco_c::sptr":
        r"""make(vco_c_sptr self, double sampling_rate, double sensitivity, double amplitude) -> vco_c_sptr"""
        return _blocks_swig6.vco_c_sptr_make(self, sampling_rate, sensitivity, amplitude)

    def history(self) -> "unsigned int":
        r"""history(vco_c_sptr self) -> unsigned int"""
        return _blocks_swig6.vco_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(vco_c_sptr self, int which, int delay)
        declare_sample_delay(vco_c_sptr self, unsigned int delay)
        """
        return _blocks_swig6.vco_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(vco_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.vco_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(vco_c_sptr self, int multiple)"""
        return _blocks_swig6.vco_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(vco_c_sptr self) -> int"""
        return _blocks_swig6.vco_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(vco_c_sptr self) -> double"""
        return _blocks_swig6.vco_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(vco_c_sptr self) -> uint64_t"""
        return _blocks_swig6.vco_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(vco_c_sptr self) -> uint64_t"""
        return _blocks_swig6.vco_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(vco_c_sptr self) -> bool"""
        return _blocks_swig6.vco_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(vco_c_sptr self) -> bool"""
        return _blocks_swig6.vco_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(vco_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.vco_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(vco_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.vco_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(vco_c_sptr self, std::string level)"""
        return _blocks_swig6.vco_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(vco_c_sptr self) -> std::string"""
        return _blocks_swig6.vco_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(vco_c_sptr self) -> int"""
        return _blocks_swig6.vco_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(vco_c_sptr self, int m)"""
        return _blocks_swig6.vco_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(vco_c_sptr self)"""
        return _blocks_swig6.vco_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(vco_c_sptr self) -> bool"""
        return _blocks_swig6.vco_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(vco_c_sptr self, int m)"""
        return _blocks_swig6.vco_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(vco_c_sptr self) -> int"""
        return _blocks_swig6.vco_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(vco_c_sptr self, int i) -> long"""
        return _blocks_swig6.vco_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(vco_c_sptr self, long max_output_buffer)
        set_max_output_buffer(vco_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.vco_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(vco_c_sptr self, int i) -> long"""
        return _blocks_swig6.vco_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(vco_c_sptr self, long min_output_buffer)
        set_min_output_buffer(vco_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.vco_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(vco_c_sptr self, int which) -> float
        pc_input_buffers_full(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_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(vco_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_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(vco_c_sptr self, int which) -> float
        pc_input_buffers_full_var(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_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(vco_c_sptr self, int which) -> float
        pc_output_buffers_full(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_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(vco_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_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(vco_c_sptr self, int which) -> float
        pc_output_buffers_full_var(vco_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.vco_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(vco_c_sptr self) -> float"""
        return _blocks_swig6.vco_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(vco_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.vco_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(vco_c_sptr self)"""
        return _blocks_swig6.vco_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(vco_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.vco_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(vco_c_sptr self) -> int"""
        return _blocks_swig6.vco_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(vco_c_sptr self) -> int"""
        return _blocks_swig6.vco_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(vco_c_sptr self, int priority) -> int"""
        return _blocks_swig6.vco_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(vco_c_sptr self) -> std::string"""
        return _blocks_swig6.vco_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(vco_c_sptr self) -> std::string"""
        return _blocks_swig6.vco_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(vco_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.vco_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(vco_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.vco_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(vco_c_sptr self) -> long"""
        return _blocks_swig6.vco_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(vco_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.vco_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(vco_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.vco_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(vco_c_sptr self) -> std::string"""
        return _blocks_swig6.vco_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(vco_c_sptr self, std::string name)"""
        return _blocks_swig6.vco_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(vco_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.vco_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(vco_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(vco_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(vco_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.vco_c_sptr_message_subscribers(self, which_port)

# Register vco_c_sptr in _blocks_swig6:
_blocks_swig6.vco_c_sptr_swigregister(vco_c_sptr)


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

class xor_bb(object):
    r"""Proxy of C++ gr::blocks::xor_blk< 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(vlen: "size_t"=1) -> "gr::blocks::xor_blk< unsigned char >::sptr":
        r"""make(size_t vlen=1) -> xor_bb_sptr"""
        return _blocks_swig6.xor_bb_make(vlen)
    __swig_destroy__ = _blocks_swig6.delete_xor_bb

# Register xor_bb in _blocks_swig6:
_blocks_swig6.xor_bb_swigregister(xor_bb)

def xor_bb_make(vlen: "size_t"=1) -> "gr::blocks::xor_blk< unsigned char >::sptr":
    r"""xor_bb_make(size_t vlen=1) -> xor_bb_sptr"""
    return _blocks_swig6.xor_bb_make(vlen)

class xor_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::xor_blk< 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__(xor_bb_sptr self) -> xor_bb_sptr
        __init__(xor_bb_sptr self, xor_bb p) -> xor_bb_sptr
        """
        _blocks_swig6.xor_bb_sptr_swiginit(self, _blocks_swig6.new_xor_bb_sptr(*args))

    def __deref__(self) -> "gr::blocks::xor_blk< std::uint8_t > *":
        r"""__deref__(xor_bb_sptr self) -> xor_bb"""
        return _blocks_swig6.xor_bb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_xor_bb_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::xor_blk< unsigned char >::sptr":
        r"""make(xor_bb_sptr self, size_t vlen=1) -> xor_bb_sptr"""
        return _blocks_swig6.xor_bb_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(xor_bb_sptr self) -> unsigned int"""
        return _blocks_swig6.xor_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(xor_bb_sptr self, int which, int delay)
        declare_sample_delay(xor_bb_sptr self, unsigned int delay)
        """
        return _blocks_swig6.xor_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(xor_bb_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.xor_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(xor_bb_sptr self, int multiple)"""
        return _blocks_swig6.xor_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(xor_bb_sptr self) -> int"""
        return _blocks_swig6.xor_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(xor_bb_sptr self) -> double"""
        return _blocks_swig6.xor_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(xor_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(xor_bb_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(xor_bb_sptr self) -> bool"""
        return _blocks_swig6.xor_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(xor_bb_sptr self) -> bool"""
        return _blocks_swig6.xor_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(xor_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.xor_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(xor_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.xor_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(xor_bb_sptr self, std::string level)"""
        return _blocks_swig6.xor_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(xor_bb_sptr self) -> std::string"""
        return _blocks_swig6.xor_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(xor_bb_sptr self) -> int"""
        return _blocks_swig6.xor_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(xor_bb_sptr self, int m)"""
        return _blocks_swig6.xor_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(xor_bb_sptr self)"""
        return _blocks_swig6.xor_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(xor_bb_sptr self) -> bool"""
        return _blocks_swig6.xor_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(xor_bb_sptr self, int m)"""
        return _blocks_swig6.xor_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(xor_bb_sptr self) -> int"""
        return _blocks_swig6.xor_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(xor_bb_sptr self, int i) -> long"""
        return _blocks_swig6.xor_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(xor_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_bb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.xor_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(xor_bb_sptr self, int i) -> long"""
        return _blocks_swig6.xor_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(xor_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_bb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.xor_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_bb_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(xor_bb_sptr self) -> float"""
        return _blocks_swig6.xor_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(xor_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.xor_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(xor_bb_sptr self)"""
        return _blocks_swig6.xor_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(xor_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.xor_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(xor_bb_sptr self) -> int"""
        return _blocks_swig6.xor_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(xor_bb_sptr self) -> int"""
        return _blocks_swig6.xor_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(xor_bb_sptr self, int priority) -> int"""
        return _blocks_swig6.xor_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(xor_bb_sptr self) -> std::string"""
        return _blocks_swig6.xor_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(xor_bb_sptr self) -> std::string"""
        return _blocks_swig6.xor_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(xor_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(xor_bb_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(xor_bb_sptr self) -> long"""
        return _blocks_swig6.xor_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(xor_bb_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.xor_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(xor_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.xor_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(xor_bb_sptr self) -> std::string"""
        return _blocks_swig6.xor_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(xor_bb_sptr self, std::string name)"""
        return _blocks_swig6.xor_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(xor_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.xor_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(xor_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(xor_bb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(xor_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_bb_sptr_message_subscribers(self, which_port)

# Register xor_bb_sptr in _blocks_swig6:
_blocks_swig6.xor_bb_sptr_swigregister(xor_bb_sptr)


xor_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
xor_bb = xor_bb.make

class xor_ss(object):
    r"""Proxy of C++ gr::blocks::xor_blk< 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::xor_blk< short >::sptr":
        r"""make(size_t vlen=1) -> xor_ss_sptr"""
        return _blocks_swig6.xor_ss_make(vlen)
    __swig_destroy__ = _blocks_swig6.delete_xor_ss

# Register xor_ss in _blocks_swig6:
_blocks_swig6.xor_ss_swigregister(xor_ss)

def xor_ss_make(vlen: "size_t"=1) -> "gr::blocks::xor_blk< short >::sptr":
    r"""xor_ss_make(size_t vlen=1) -> xor_ss_sptr"""
    return _blocks_swig6.xor_ss_make(vlen)

class xor_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::xor_blk< 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__(xor_ss_sptr self) -> xor_ss_sptr
        __init__(xor_ss_sptr self, xor_ss p) -> xor_ss_sptr
        """
        _blocks_swig6.xor_ss_sptr_swiginit(self, _blocks_swig6.new_xor_ss_sptr(*args))

    def __deref__(self) -> "gr::blocks::xor_blk< std::int16_t > *":
        r"""__deref__(xor_ss_sptr self) -> xor_ss"""
        return _blocks_swig6.xor_ss_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_xor_ss_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::xor_blk< short >::sptr":
        r"""make(xor_ss_sptr self, size_t vlen=1) -> xor_ss_sptr"""
        return _blocks_swig6.xor_ss_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(xor_ss_sptr self) -> unsigned int"""
        return _blocks_swig6.xor_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(xor_ss_sptr self, int which, int delay)
        declare_sample_delay(xor_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig6.xor_ss_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(xor_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.xor_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(xor_ss_sptr self, int multiple)"""
        return _blocks_swig6.xor_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(xor_ss_sptr self) -> int"""
        return _blocks_swig6.xor_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(xor_ss_sptr self) -> double"""
        return _blocks_swig6.xor_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(xor_ss_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(xor_ss_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(xor_ss_sptr self) -> bool"""
        return _blocks_swig6.xor_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(xor_ss_sptr self) -> bool"""
        return _blocks_swig6.xor_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(xor_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.xor_ss_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(xor_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.xor_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(xor_ss_sptr self, std::string level)"""
        return _blocks_swig6.xor_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(xor_ss_sptr self) -> std::string"""
        return _blocks_swig6.xor_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(xor_ss_sptr self) -> int"""
        return _blocks_swig6.xor_ss_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(xor_ss_sptr self, int m)"""
        return _blocks_swig6.xor_ss_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(xor_ss_sptr self)"""
        return _blocks_swig6.xor_ss_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(xor_ss_sptr self) -> bool"""
        return _blocks_swig6.xor_ss_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(xor_ss_sptr self, int m)"""
        return _blocks_swig6.xor_ss_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(xor_ss_sptr self) -> int"""
        return _blocks_swig6.xor_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(xor_ss_sptr self, int i) -> long"""
        return _blocks_swig6.xor_ss_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(xor_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.xor_ss_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(xor_ss_sptr self, int i) -> long"""
        return _blocks_swig6.xor_ss_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(xor_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.xor_ss_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_ss_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(xor_ss_sptr self) -> float"""
        return _blocks_swig6.xor_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(xor_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.xor_ss_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(xor_ss_sptr self)"""
        return _blocks_swig6.xor_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(xor_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.xor_ss_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(xor_ss_sptr self) -> int"""
        return _blocks_swig6.xor_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(xor_ss_sptr self) -> int"""
        return _blocks_swig6.xor_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(xor_ss_sptr self, int priority) -> int"""
        return _blocks_swig6.xor_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(xor_ss_sptr self) -> std::string"""
        return _blocks_swig6.xor_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(xor_ss_sptr self) -> std::string"""
        return _blocks_swig6.xor_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(xor_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(xor_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(xor_ss_sptr self) -> long"""
        return _blocks_swig6.xor_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(xor_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.xor_ss_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(xor_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.xor_ss_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(xor_ss_sptr self) -> std::string"""
        return _blocks_swig6.xor_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(xor_ss_sptr self, std::string name)"""
        return _blocks_swig6.xor_ss_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(xor_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.xor_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(xor_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(xor_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(xor_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ss_sptr_message_subscribers(self, which_port)

# Register xor_ss_sptr in _blocks_swig6:
_blocks_swig6.xor_ss_sptr_swigregister(xor_ss_sptr)


xor_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
xor_ss = xor_ss.make

class xor_ii(object):
    r"""Proxy of C++ gr::blocks::xor_blk< 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::xor_blk< int >::sptr":
        r"""make(size_t vlen=1) -> xor_ii_sptr"""
        return _blocks_swig6.xor_ii_make(vlen)
    __swig_destroy__ = _blocks_swig6.delete_xor_ii

# Register xor_ii in _blocks_swig6:
_blocks_swig6.xor_ii_swigregister(xor_ii)

def xor_ii_make(vlen: "size_t"=1) -> "gr::blocks::xor_blk< int >::sptr":
    r"""xor_ii_make(size_t vlen=1) -> xor_ii_sptr"""
    return _blocks_swig6.xor_ii_make(vlen)

class xor_ii_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::xor_blk< 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__(xor_ii_sptr self) -> xor_ii_sptr
        __init__(xor_ii_sptr self, xor_ii p) -> xor_ii_sptr
        """
        _blocks_swig6.xor_ii_sptr_swiginit(self, _blocks_swig6.new_xor_ii_sptr(*args))

    def __deref__(self) -> "gr::blocks::xor_blk< std::int32_t > *":
        r"""__deref__(xor_ii_sptr self) -> xor_ii"""
        return _blocks_swig6.xor_ii_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig6.delete_xor_ii_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::xor_blk< int >::sptr":
        r"""make(xor_ii_sptr self, size_t vlen=1) -> xor_ii_sptr"""
        return _blocks_swig6.xor_ii_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(xor_ii_sptr self) -> unsigned int"""
        return _blocks_swig6.xor_ii_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(xor_ii_sptr self, int which, int delay)
        declare_sample_delay(xor_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig6.xor_ii_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(xor_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig6.xor_ii_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(xor_ii_sptr self, int multiple)"""
        return _blocks_swig6.xor_ii_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(xor_ii_sptr self) -> int"""
        return _blocks_swig6.xor_ii_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(xor_ii_sptr self) -> double"""
        return _blocks_swig6.xor_ii_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(xor_ii_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_ii_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(xor_ii_sptr self) -> uint64_t"""
        return _blocks_swig6.xor_ii_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(xor_ii_sptr self) -> bool"""
        return _blocks_swig6.xor_ii_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(xor_ii_sptr self) -> bool"""
        return _blocks_swig6.xor_ii_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(xor_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig6.xor_ii_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(xor_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig6.xor_ii_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(xor_ii_sptr self, std::string level)"""
        return _blocks_swig6.xor_ii_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(xor_ii_sptr self) -> std::string"""
        return _blocks_swig6.xor_ii_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(xor_ii_sptr self) -> int"""
        return _blocks_swig6.xor_ii_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(xor_ii_sptr self, int m)"""
        return _blocks_swig6.xor_ii_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(xor_ii_sptr self)"""
        return _blocks_swig6.xor_ii_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(xor_ii_sptr self) -> bool"""
        return _blocks_swig6.xor_ii_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(xor_ii_sptr self, int m)"""
        return _blocks_swig6.xor_ii_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(xor_ii_sptr self) -> int"""
        return _blocks_swig6.xor_ii_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(xor_ii_sptr self, int i) -> long"""
        return _blocks_swig6.xor_ii_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(xor_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(xor_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig6.xor_ii_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(xor_ii_sptr self, int i) -> long"""
        return _blocks_swig6.xor_ii_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(xor_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(xor_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig6.xor_ii_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_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(xor_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(xor_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig6.xor_ii_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(xor_ii_sptr self) -> float"""
        return _blocks_swig6.xor_ii_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(xor_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig6.xor_ii_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(xor_ii_sptr self)"""
        return _blocks_swig6.xor_ii_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(xor_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig6.xor_ii_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(xor_ii_sptr self) -> int"""
        return _blocks_swig6.xor_ii_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(xor_ii_sptr self) -> int"""
        return _blocks_swig6.xor_ii_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(xor_ii_sptr self, int priority) -> int"""
        return _blocks_swig6.xor_ii_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(xor_ii_sptr self) -> std::string"""
        return _blocks_swig6.xor_ii_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(xor_ii_sptr self) -> std::string"""
        return _blocks_swig6.xor_ii_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(xor_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_ii_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(xor_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig6.xor_ii_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(xor_ii_sptr self) -> long"""
        return _blocks_swig6.xor_ii_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(xor_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig6.xor_ii_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(xor_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig6.xor_ii_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(xor_ii_sptr self) -> std::string"""
        return _blocks_swig6.xor_ii_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(xor_ii_sptr self, std::string name)"""
        return _blocks_swig6.xor_ii_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(xor_ii_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig6.xor_ii_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(xor_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ii_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(xor_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ii_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(xor_ii_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig6.xor_ii_sptr_message_subscribers(self, which_port)

# Register xor_ii_sptr in _blocks_swig6:
_blocks_swig6.xor_ii_sptr_swigregister(xor_ii_sptr)


xor_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
xor_ii = xor_ii.make



