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

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 _fec_swig.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 _fec_swig.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 _fec_swig.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 _fec_swig.high_res_timer_epoch()
CC_STREAMING = _fec_swig.CC_STREAMING

CC_TERMINATED = _fec_swig.CC_TERMINATED

CC_TRUNCATED = _fec_swig.CC_TRUNCATED

CC_TAILBITING = _fec_swig.CC_TAILBITING

class decision_t(object):
    r"""Proxy of C++ decision_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    t = property(_fec_swig.decision_t_t_get, _fec_swig.decision_t_t_set, doc=r"""t : p.unsigned char""")
    w = property(_fec_swig.decision_t_w_get, _fec_swig.decision_t_w_set, doc=r"""w : p.unsigned int""")
    s = property(_fec_swig.decision_t_s_get, _fec_swig.decision_t_s_set, doc=r"""s : p.unsigned short""")
    c = property(_fec_swig.decision_t_c_get, _fec_swig.decision_t_c_set, doc=r"""c : p.unsigned char""")

    def __init__(self):
        r"""__init__(decision_t self) -> decision_t"""
        _fec_swig.decision_t_swiginit(self, _fec_swig.new_decision_t())
    __swig_destroy__ = _fec_swig.delete_decision_t

# Register decision_t in _fec_swig:
_fec_swig.decision_t_swigregister(decision_t)

class metric_t(object):
    r"""Proxy of C++ metric_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    t = property(_fec_swig.metric_t_t_get, _fec_swig.metric_t_t_set, doc=r"""t : p.unsigned char""")

    def __init__(self):
        r"""__init__(metric_t self) -> metric_t"""
        _fec_swig.metric_t_swiginit(self, _fec_swig.new_metric_t())
    __swig_destroy__ = _fec_swig.delete_metric_t

# Register metric_t in _fec_swig:
_fec_swig.metric_t_swigregister(metric_t)

class v(object):
    r"""Proxy of C++ v class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    metrics = property(_fec_swig.v_metrics_get, _fec_swig.v_metrics_set, doc=r"""metrics : p.unsigned char""")
    old_metrics = property(_fec_swig.v_old_metrics_get, _fec_swig.v_old_metrics_set, doc=r"""old_metrics : metric_t""")
    new_metrics = property(_fec_swig.v_new_metrics_get, _fec_swig.v_new_metrics_set, doc=r"""new_metrics : metric_t""")
    metrics1 = property(_fec_swig.v_metrics1_get, _fec_swig.v_metrics1_set, doc=r"""metrics1 : metric_t""")
    metrics2 = property(_fec_swig.v_metrics2_get, _fec_swig.v_metrics2_set, doc=r"""metrics2 : metric_t""")
    decisions = property(_fec_swig.v_decisions_get, _fec_swig.v_decisions_set, doc=r"""decisions : p.unsigned char""")

    def __init__(self):
        r"""__init__(v self) -> v"""
        _fec_swig.v_swiginit(self, _fec_swig.new_v())
    __swig_destroy__ = _fec_swig.delete_v

# Register v in _fec_swig:
_fec_swig.v_swigregister(v)

class generic_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::generic_encoder > 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__(generic_encoder_sptr self) -> generic_encoder_sptr
        __init__(generic_encoder_sptr self, generic_encoder p) -> generic_encoder_sptr
        """
        _fec_swig.generic_encoder_sptr_swiginit(self, _fec_swig.new_generic_encoder_sptr(*args))

    def __deref__(self) -> "gr::fec::generic_encoder *":
        r"""__deref__(generic_encoder_sptr self) -> generic_encoder"""
        return _fec_swig.generic_encoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_generic_encoder_sptr

    def generic_work(self, in_buffer: "void *", out_buffer: "void *") -> "void":
        r"""generic_work(generic_encoder_sptr self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.generic_encoder_sptr_generic_work(self, in_buffer, out_buffer)
    base_unique_id = property(_fec_swig.generic_encoder_sptr_base_unique_id_get, _fec_swig.generic_encoder_sptr_base_unique_id_set, doc=r"""base_unique_id : int""")
    my_id = property(_fec_swig.generic_encoder_sptr_my_id_get, _fec_swig.generic_encoder_sptr_my_id_set, doc=r"""my_id : int""")

    def unique_id(self) -> "int":
        r"""unique_id(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_unique_id(self)
    d_name = property(_fec_swig.generic_encoder_sptr_d_name_get, _fec_swig.generic_encoder_sptr_d_name_set, doc=r"""d_name : std::string""")

    def alias(self) -> "std::string":
        r"""alias(generic_encoder_sptr self) -> std::string"""
        return _fec_swig.generic_encoder_sptr_alias(self)

    def rate(self) -> "double":
        r"""rate(generic_encoder_sptr self) -> double"""
        return _fec_swig.generic_encoder_sptr_rate(self)

    def get_input_size(self) -> "int":
        r"""get_input_size(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_get_input_size(self)

    def get_output_size(self) -> "int":
        r"""get_output_size(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_get_output_size(self)

    def get_input_conversion(self) -> "char const *":
        r"""get_input_conversion(generic_encoder_sptr self) -> char const *"""
        return _fec_swig.generic_encoder_sptr_get_input_conversion(self)

    def get_output_conversion(self) -> "char const *":
        r"""get_output_conversion(generic_encoder_sptr self) -> char const *"""
        return _fec_swig.generic_encoder_sptr_get_output_conversion(self)

    def set_frame_size(self, frame_size: "unsigned int") -> "bool":
        r"""set_frame_size(generic_encoder_sptr self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_encoder_sptr_set_frame_size(self, frame_size)

# Register generic_encoder_sptr in _fec_swig:
_fec_swig.generic_encoder_sptr_swigregister(generic_encoder_sptr)

class generic_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::generic_decoder > 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__(generic_decoder_sptr self) -> generic_decoder_sptr
        __init__(generic_decoder_sptr self, generic_decoder p) -> generic_decoder_sptr
        """
        _fec_swig.generic_decoder_sptr_swiginit(self, _fec_swig.new_generic_decoder_sptr(*args))

    def __deref__(self) -> "gr::fec::generic_decoder *":
        r"""__deref__(generic_decoder_sptr self) -> generic_decoder"""
        return _fec_swig.generic_decoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_generic_decoder_sptr

    def generic_work(self, inbuffer: "void *", outbuffer: "void *") -> "void":
        r"""generic_work(generic_decoder_sptr self, void * inbuffer, void * outbuffer)"""
        return _fec_swig.generic_decoder_sptr_generic_work(self, inbuffer, outbuffer)
    base_unique_id = property(_fec_swig.generic_decoder_sptr_base_unique_id_get, _fec_swig.generic_decoder_sptr_base_unique_id_set, doc=r"""base_unique_id : int""")
    my_id = property(_fec_swig.generic_decoder_sptr_my_id_get, _fec_swig.generic_decoder_sptr_my_id_set, doc=r"""my_id : int""")

    def unique_id(self) -> "int":
        r"""unique_id(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_unique_id(self)
    d_name = property(_fec_swig.generic_decoder_sptr_d_name_get, _fec_swig.generic_decoder_sptr_d_name_set, doc=r"""d_name : std::string""")

    def alias(self) -> "std::string":
        r"""alias(generic_decoder_sptr self) -> std::string"""
        return _fec_swig.generic_decoder_sptr_alias(self)

    def rate(self) -> "double":
        r"""rate(generic_decoder_sptr self) -> double"""
        return _fec_swig.generic_decoder_sptr_rate(self)

    def get_input_size(self) -> "int":
        r"""get_input_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_input_size(self)

    def get_output_size(self) -> "int":
        r"""get_output_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_output_size(self)

    def get_history(self) -> "int":
        r"""get_history(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_history(self)

    def get_shift(self) -> "float":
        r"""get_shift(generic_decoder_sptr self) -> float"""
        return _fec_swig.generic_decoder_sptr_get_shift(self)

    def get_input_item_size(self) -> "int":
        r"""get_input_item_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_input_item_size(self)

    def get_output_item_size(self) -> "int":
        r"""get_output_item_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_output_item_size(self)

    def get_input_conversion(self) -> "char const *":
        r"""get_input_conversion(generic_decoder_sptr self) -> char const *"""
        return _fec_swig.generic_decoder_sptr_get_input_conversion(self)

    def get_output_conversion(self) -> "char const *":
        r"""get_output_conversion(generic_decoder_sptr self) -> char const *"""
        return _fec_swig.generic_decoder_sptr_get_output_conversion(self)

    def set_frame_size(self, frame_size: "unsigned int") -> "bool":
        r"""set_frame_size(generic_decoder_sptr self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_decoder_sptr_set_frame_size(self, frame_size)

    def get_iterations(self) -> "float":
        r"""get_iterations(generic_decoder_sptr self) -> float"""
        return _fec_swig.generic_decoder_sptr_get_iterations(self)

# Register generic_decoder_sptr in _fec_swig:
_fec_swig.generic_decoder_sptr_swigregister(generic_decoder_sptr)

class generic_decoder(object):
    r"""Proxy of C++ gr::fec::generic_decoder 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 generic_work(self, inbuffer: "void *", outbuffer: "void *") -> "void":
        r"""generic_work(generic_decoder self, void * inbuffer, void * outbuffer)"""
        return _fec_swig.generic_decoder_generic_work(self, inbuffer, outbuffer)
    base_unique_id = property(_fec_swig.generic_decoder_base_unique_id_get, _fec_swig.generic_decoder_base_unique_id_set, doc=r"""base_unique_id : int""")
    my_id = property(_fec_swig.generic_decoder_my_id_get, _fec_swig.generic_decoder_my_id_set, doc=r"""my_id : int""")

    def unique_id(self) -> "int":
        r"""unique_id(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_unique_id(self)
    d_name = property(_fec_swig.generic_decoder_d_name_get, _fec_swig.generic_decoder_d_name_set, doc=r"""d_name : std::string""")

    def alias(self) -> "std::string":
        r"""alias(generic_decoder self) -> std::string"""
        return _fec_swig.generic_decoder_alias(self)
    __swig_destroy__ = _fec_swig.delete_generic_decoder

    def rate(self) -> "double":
        r"""rate(generic_decoder self) -> double"""
        return _fec_swig.generic_decoder_rate(self)

    def get_input_size(self) -> "int":
        r"""get_input_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_input_size(self)

    def get_output_size(self) -> "int":
        r"""get_output_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_output_size(self)

    def get_history(self) -> "int":
        r"""get_history(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_history(self)

    def get_shift(self) -> "float":
        r"""get_shift(generic_decoder self) -> float"""
        return _fec_swig.generic_decoder_get_shift(self)

    def get_input_item_size(self) -> "int":
        r"""get_input_item_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_input_item_size(self)

    def get_output_item_size(self) -> "int":
        r"""get_output_item_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_output_item_size(self)

    def get_input_conversion(self) -> "char const *":
        r"""get_input_conversion(generic_decoder self) -> char const *"""
        return _fec_swig.generic_decoder_get_input_conversion(self)

    def get_output_conversion(self) -> "char const *":
        r"""get_output_conversion(generic_decoder self) -> char const *"""
        return _fec_swig.generic_decoder_get_output_conversion(self)

    def set_frame_size(self, frame_size: "unsigned int") -> "bool":
        r"""set_frame_size(generic_decoder self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_decoder_set_frame_size(self, frame_size)

    def get_iterations(self) -> "float":
        r"""get_iterations(generic_decoder self) -> float"""
        return _fec_swig.generic_decoder_get_iterations(self)

# Register generic_decoder in _fec_swig:
_fec_swig.generic_decoder_swigregister(generic_decoder)
cvar = _fec_swig.cvar


def get_decoder_output_size(my_decoder: "generic_decoder_sptr") -> "int":
    r"""get_decoder_output_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_output_size(my_decoder)

def get_decoder_input_size(my_decoder: "generic_decoder_sptr") -> "int":
    r"""get_decoder_input_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_input_size(my_decoder)

def get_shift(my_decoder: "generic_decoder_sptr") -> "float":
    r"""get_shift(generic_decoder_sptr my_decoder) -> float"""
    return _fec_swig.get_shift(my_decoder)

def get_history(my_decoder: "generic_decoder_sptr") -> "int":
    r"""get_history(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_history(my_decoder)

def get_decoder_input_item_size(my_decoder: "generic_decoder_sptr") -> "int":
    r"""get_decoder_input_item_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_input_item_size(my_decoder)

def get_decoder_output_item_size(my_decoder: "generic_decoder_sptr") -> "int":
    r"""get_decoder_output_item_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_output_item_size(my_decoder)

def get_decoder_input_conversion(my_decoder: "generic_decoder_sptr") -> "char const *":
    r"""get_decoder_input_conversion(generic_decoder_sptr my_decoder) -> char const *"""
    return _fec_swig.get_decoder_input_conversion(my_decoder)

def get_decoder_output_conversion(my_decoder: "generic_decoder_sptr") -> "char const *":
    r"""get_decoder_output_conversion(generic_decoder_sptr my_decoder) -> char const *"""
    return _fec_swig.get_decoder_output_conversion(my_decoder)
class generic_encoder(object):
    r"""Proxy of C++ gr::fec::generic_encoder 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 generic_work(self, in_buffer: "void *", out_buffer: "void *") -> "void":
        r"""generic_work(generic_encoder self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.generic_encoder_generic_work(self, in_buffer, out_buffer)
    base_unique_id = property(_fec_swig.generic_encoder_base_unique_id_get, _fec_swig.generic_encoder_base_unique_id_set, doc=r"""base_unique_id : int""")
    my_id = property(_fec_swig.generic_encoder_my_id_get, _fec_swig.generic_encoder_my_id_set, doc=r"""my_id : int""")

    def unique_id(self) -> "int":
        r"""unique_id(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_unique_id(self)
    d_name = property(_fec_swig.generic_encoder_d_name_get, _fec_swig.generic_encoder_d_name_set, doc=r"""d_name : std::string""")

    def alias(self) -> "std::string":
        r"""alias(generic_encoder self) -> std::string"""
        return _fec_swig.generic_encoder_alias(self)

    def rate(self) -> "double":
        r"""rate(generic_encoder self) -> double"""
        return _fec_swig.generic_encoder_rate(self)

    def get_input_size(self) -> "int":
        r"""get_input_size(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_get_input_size(self)

    def get_output_size(self) -> "int":
        r"""get_output_size(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_get_output_size(self)

    def get_input_conversion(self) -> "char const *":
        r"""get_input_conversion(generic_encoder self) -> char const *"""
        return _fec_swig.generic_encoder_get_input_conversion(self)

    def get_output_conversion(self) -> "char const *":
        r"""get_output_conversion(generic_encoder self) -> char const *"""
        return _fec_swig.generic_encoder_get_output_conversion(self)

    def set_frame_size(self, frame_size: "unsigned int") -> "bool":
        r"""set_frame_size(generic_encoder self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_encoder_set_frame_size(self, frame_size)
    __swig_destroy__ = _fec_swig.delete_generic_encoder

# Register generic_encoder in _fec_swig:
_fec_swig.generic_encoder_swigregister(generic_encoder)


def get_encoder_output_size(my_encoder: "generic_encoder_sptr") -> "int":
    r"""get_encoder_output_size(generic_encoder_sptr my_encoder) -> int"""
    return _fec_swig.get_encoder_output_size(my_encoder)

def get_encoder_input_size(my_encoder: "generic_encoder_sptr") -> "int":
    r"""get_encoder_input_size(generic_encoder_sptr my_encoder) -> int"""
    return _fec_swig.get_encoder_input_size(my_encoder)

def get_encoder_input_conversion(my_encoder: "generic_encoder_sptr") -> "char const *":
    r"""get_encoder_input_conversion(generic_encoder_sptr my_encoder) -> char const *"""
    return _fec_swig.get_encoder_input_conversion(my_encoder)

def get_encoder_output_conversion(my_encoder: "generic_encoder_sptr") -> "char const *":
    r"""get_encoder_output_conversion(generic_encoder_sptr my_encoder) -> char const *"""
    return _fec_swig.get_encoder_output_conversion(my_encoder)
class decoder(object):
    r"""Proxy of C++ gr::fec::decoder 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(my_decoder: "generic_decoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::decoder::sptr":
        r"""make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
        return _fec_swig.decoder_make(my_decoder, input_item_size, output_item_size)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.decoder_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def fixed_rate_ninput_to_noutput(self, ninput: "int") -> "int":
        r"""fixed_rate_ninput_to_noutput(decoder self, int ninput) -> int"""
        return _fec_swig.decoder_fixed_rate_ninput_to_noutput(self, ninput)

    def fixed_rate_noutput_to_ninput(self, noutput: "int") -> "int":
        r"""fixed_rate_noutput_to_ninput(decoder self, int noutput) -> int"""
        return _fec_swig.decoder_fixed_rate_noutput_to_ninput(self, noutput)

    def forecast(self, noutput_items: "int", ninput_items_required: "gr_vector_int &") -> "void":
        r"""forecast(decoder self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.decoder_forecast(self, noutput_items, ninput_items_required)
    __swig_destroy__ = _fec_swig.delete_decoder

# Register decoder in _fec_swig:
_fec_swig.decoder_swigregister(decoder)

def decoder_make(my_decoder: "generic_decoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::decoder::sptr":
    r"""decoder_make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
    return _fec_swig.decoder_make(my_decoder, input_item_size, output_item_size)

class encoder(object):
    r"""Proxy of C++ gr::fec::encoder 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(my_encoder: "generic_encoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::encoder::sptr":
        r"""make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
        return _fec_swig.encoder_make(my_encoder, input_item_size, output_item_size)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.encoder_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def fixed_rate_ninput_to_noutput(self, ninput: "int") -> "int":
        r"""fixed_rate_ninput_to_noutput(encoder self, int ninput) -> int"""
        return _fec_swig.encoder_fixed_rate_ninput_to_noutput(self, ninput)

    def fixed_rate_noutput_to_ninput(self, noutput: "int") -> "int":
        r"""fixed_rate_noutput_to_ninput(encoder self, int noutput) -> int"""
        return _fec_swig.encoder_fixed_rate_noutput_to_ninput(self, noutput)

    def forecast(self, noutput_items: "int", ninput_items_required: "gr_vector_int &") -> "void":
        r"""forecast(encoder self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.encoder_forecast(self, noutput_items, ninput_items_required)
    __swig_destroy__ = _fec_swig.delete_encoder

# Register encoder in _fec_swig:
_fec_swig.encoder_swigregister(encoder)

def encoder_make(my_encoder: "generic_encoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::encoder::sptr":
    r"""encoder_make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
    return _fec_swig.encoder_make(my_encoder, input_item_size, output_item_size)

class tagged_decoder(object):
    r"""Proxy of C++ gr::fec::tagged_decoder 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::fec::tagged_decoder::sptr":
        r"""make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_decoder_sptr"""
        return _fec_swig.tagged_decoder_make(*args, **kwargs)

    def work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""work(tagged_decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_decoder_work(self, noutput_items, ninput_items, input_items, output_items)

    def calculate_output_stream_length(self, ninput_items: "gr_vector_int const &") -> "int":
        r"""calculate_output_stream_length(tagged_decoder self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_decoder_calculate_output_stream_length(self, ninput_items)
    __swig_destroy__ = _fec_swig.delete_tagged_decoder

# Register tagged_decoder in _fec_swig:
_fec_swig.tagged_decoder_swigregister(tagged_decoder)

def tagged_decoder_make(*args, **kwargs) -> "gr::fec::tagged_decoder::sptr":
    r"""tagged_decoder_make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_decoder_sptr"""
    return _fec_swig.tagged_decoder_make(*args, **kwargs)

class tagged_encoder(object):
    r"""Proxy of C++ gr::fec::tagged_encoder 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::fec::tagged_encoder::sptr":
        r"""make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_encoder_sptr"""
        return _fec_swig.tagged_encoder_make(*args, **kwargs)

    def work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""work(tagged_encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_encoder_work(self, noutput_items, ninput_items, input_items, output_items)

    def calculate_output_stream_length(self, ninput_items: "gr_vector_int const &") -> "int":
        r"""calculate_output_stream_length(tagged_encoder self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_encoder_calculate_output_stream_length(self, ninput_items)
    __swig_destroy__ = _fec_swig.delete_tagged_encoder

# Register tagged_encoder in _fec_swig:
_fec_swig.tagged_encoder_swigregister(tagged_encoder)

def tagged_encoder_make(*args, **kwargs) -> "gr::fec::tagged_encoder::sptr":
    r"""tagged_encoder_make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_encoder_sptr"""
    return _fec_swig.tagged_encoder_make(*args, **kwargs)

class async_decoder(object):
    r"""Proxy of C++ gr::fec::async_decoder 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(my_decoder: "generic_decoder_sptr", packed: "bool"=False, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_decoder::sptr":
        r"""make(generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
        return _fec_swig.async_decoder_make(my_decoder, packed, rev_pack, mtu)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(async_decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_decoder_general_work(self, noutput_items, ninput_items, input_items, output_items)
    __swig_destroy__ = _fec_swig.delete_async_decoder

# Register async_decoder in _fec_swig:
_fec_swig.async_decoder_swigregister(async_decoder)

def async_decoder_make(my_decoder: "generic_decoder_sptr", packed: "bool"=False, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_decoder::sptr":
    r"""async_decoder_make(generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
    return _fec_swig.async_decoder_make(my_decoder, packed, rev_pack, mtu)

class async_encoder(object):
    r"""Proxy of C++ gr::fec::async_encoder 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(my_encoder: "generic_encoder_sptr", packed: "bool"=False, rev_unpack: "bool"=True, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_encoder::sptr":
        r"""make(generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
        return _fec_swig.async_encoder_make(my_encoder, packed, rev_unpack, rev_pack, mtu)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(async_encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_encoder_general_work(self, noutput_items, ninput_items, input_items, output_items)
    __swig_destroy__ = _fec_swig.delete_async_encoder

# Register async_encoder in _fec_swig:
_fec_swig.async_encoder_swigregister(async_encoder)

def async_encoder_make(my_encoder: "generic_encoder_sptr", packed: "bool"=False, rev_unpack: "bool"=True, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_encoder::sptr":
    r"""async_encoder_make(generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
    return _fec_swig.async_encoder_make(my_encoder, packed, rev_unpack, rev_pack, mtu)

class cc_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::code::cc_decoder 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(frame_size: "int", k: "int", rate: "int", polys: "std::vector< int,std::allocator< int > >", start_state: "int"=0, end_state: "int"=-1, mode: "cc_mode_t"=CC_STREAMING, padded: "bool"=False) -> "gr::fec::generic_decoder::sptr":
        r"""make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, int end_state=-1, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_decoder_sptr"""
        return _fec_swig.cc_decoder_make(frame_size, k, rate, polys, start_state, end_state, mode, padded)
    __swig_destroy__ = _fec_swig.delete_cc_decoder

# Register cc_decoder in _fec_swig:
_fec_swig.cc_decoder_swigregister(cc_decoder)

def cc_decoder_make(frame_size: "int", k: "int", rate: "int", polys: "std::vector< int,std::allocator< int > >", start_state: "int"=0, end_state: "int"=-1, mode: "cc_mode_t"=CC_STREAMING, padded: "bool"=False) -> "gr::fec::generic_decoder::sptr":
    r"""cc_decoder_make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, int end_state=-1, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_decoder_sptr"""
    return _fec_swig.cc_decoder_make(frame_size, k, rate, polys, start_state, end_state, mode, padded)

class cc_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::cc_encoder 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(frame_size: "int", k: "int", rate: "int", polys: "std::vector< int,std::allocator< int > >", start_state: "int"=0, mode: "cc_mode_t"=CC_STREAMING, padded: "bool"=False) -> "gr::fec::generic_encoder::sptr":
        r"""make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_encoder_sptr"""
        return _fec_swig.cc_encoder_make(frame_size, k, rate, polys, start_state, mode, padded)
    __swig_destroy__ = _fec_swig.delete_cc_encoder

# Register cc_encoder in _fec_swig:
_fec_swig.cc_encoder_swigregister(cc_encoder)

def cc_encoder_make(frame_size: "int", k: "int", rate: "int", polys: "std::vector< int,std::allocator< int > >", start_state: "int"=0, mode: "cc_mode_t"=CC_STREAMING, padded: "bool"=False) -> "gr::fec::generic_encoder::sptr":
    r"""cc_encoder_make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_encoder_sptr"""
    return _fec_swig.cc_encoder_make(frame_size, k, rate, polys, start_state, mode, padded)

class ccsds_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::ccsds_encoder 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(frame_size: "int", start_state: "int"=0, mode: "cc_mode_t"=CC_STREAMING) -> "gr::fec::generic_encoder::sptr":
        r"""make(int frame_size, int start_state=0, cc_mode_t mode=CC_STREAMING) -> generic_encoder_sptr"""
        return _fec_swig.ccsds_encoder_make(frame_size, start_state, mode)
    __swig_destroy__ = _fec_swig.delete_ccsds_encoder

# Register ccsds_encoder in _fec_swig:
_fec_swig.ccsds_encoder_swigregister(ccsds_encoder)

def ccsds_encoder_make(frame_size: "int", start_state: "int"=0, mode: "cc_mode_t"=CC_STREAMING) -> "gr::fec::generic_encoder::sptr":
    r"""ccsds_encoder_make(int frame_size, int start_state=0, cc_mode_t mode=CC_STREAMING) -> generic_encoder_sptr"""
    return _fec_swig.ccsds_encoder_make(frame_size, start_state, mode)

class dummy_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::code::dummy_decoder 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(frame_size: "int") -> "gr::fec::generic_decoder::sptr":
        r"""make(int frame_size) -> generic_decoder_sptr"""
        return _fec_swig.dummy_decoder_make(frame_size)
    __swig_destroy__ = _fec_swig.delete_dummy_decoder

# Register dummy_decoder in _fec_swig:
_fec_swig.dummy_decoder_swigregister(dummy_decoder)

def dummy_decoder_make(frame_size: "int") -> "gr::fec::generic_decoder::sptr":
    r"""dummy_decoder_make(int frame_size) -> generic_decoder_sptr"""
    return _fec_swig.dummy_decoder_make(frame_size)

class dummy_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::dummy_encoder 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(frame_size: "int", pack: "bool"=False, packed_bits: "bool"=False) -> "gr::fec::generic_encoder::sptr":
        r"""make(int frame_size, bool pack=False, bool packed_bits=False) -> generic_encoder_sptr"""
        return _fec_swig.dummy_encoder_make(frame_size, pack, packed_bits)
    __swig_destroy__ = _fec_swig.delete_dummy_encoder

# Register dummy_encoder in _fec_swig:
_fec_swig.dummy_encoder_swigregister(dummy_encoder)

def dummy_encoder_make(frame_size: "int", pack: "bool"=False, packed_bits: "bool"=False) -> "gr::fec::generic_encoder::sptr":
    r"""dummy_encoder_make(int frame_size, bool pack=False, bool packed_bits=False) -> generic_encoder_sptr"""
    return _fec_swig.dummy_encoder_make(frame_size, pack, packed_bits)

class repetition_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::code::repetition_decoder 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(frame_size: "int", rep: "int", ap_prob: "float"=0.5) -> "gr::fec::generic_decoder::sptr":
        r"""make(int frame_size, int rep, float ap_prob=0.5) -> generic_decoder_sptr"""
        return _fec_swig.repetition_decoder_make(frame_size, rep, ap_prob)
    __swig_destroy__ = _fec_swig.delete_repetition_decoder

# Register repetition_decoder in _fec_swig:
_fec_swig.repetition_decoder_swigregister(repetition_decoder)

def repetition_decoder_make(frame_size: "int", rep: "int", ap_prob: "float"=0.5) -> "gr::fec::generic_decoder::sptr":
    r"""repetition_decoder_make(int frame_size, int rep, float ap_prob=0.5) -> generic_decoder_sptr"""
    return _fec_swig.repetition_decoder_make(frame_size, rep, ap_prob)

class repetition_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::repetition_encoder 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(frame_size: "int", rep: "int") -> "gr::fec::generic_encoder::sptr":
        r"""make(int frame_size, int rep) -> generic_encoder_sptr"""
        return _fec_swig.repetition_encoder_make(frame_size, rep)
    __swig_destroy__ = _fec_swig.delete_repetition_encoder

# Register repetition_encoder in _fec_swig:
_fec_swig.repetition_encoder_swigregister(repetition_encoder)

def repetition_encoder_make(frame_size: "int", rep: "int") -> "gr::fec::generic_encoder::sptr":
    r"""repetition_encoder_make(int frame_size, int rep) -> generic_encoder_sptr"""
    return _fec_swig.repetition_encoder_make(frame_size, rep)

class decode_ccsds_27_fb(object):
    r"""Proxy of C++ gr::fec::decode_ccsds_27_fb 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::fec::decode_ccsds_27_fb::sptr":
        r"""make() -> decode_ccsds_27_fb_sptr"""
        return _fec_swig.decode_ccsds_27_fb_make()
    __swig_destroy__ = _fec_swig.delete_decode_ccsds_27_fb

# Register decode_ccsds_27_fb in _fec_swig:
_fec_swig.decode_ccsds_27_fb_swigregister(decode_ccsds_27_fb)

def decode_ccsds_27_fb_make() -> "gr::fec::decode_ccsds_27_fb::sptr":
    r"""decode_ccsds_27_fb_make() -> decode_ccsds_27_fb_sptr"""
    return _fec_swig.decode_ccsds_27_fb_make()

class encode_ccsds_27_bb(object):
    r"""Proxy of C++ gr::fec::encode_ccsds_27_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() -> "gr::fec::encode_ccsds_27_bb::sptr":
        r"""make() -> encode_ccsds_27_bb_sptr"""
        return _fec_swig.encode_ccsds_27_bb_make()
    __swig_destroy__ = _fec_swig.delete_encode_ccsds_27_bb

# Register encode_ccsds_27_bb in _fec_swig:
_fec_swig.encode_ccsds_27_bb_swigregister(encode_ccsds_27_bb)

def encode_ccsds_27_bb_make() -> "gr::fec::encode_ccsds_27_bb::sptr":
    r"""encode_ccsds_27_bb_make() -> encode_ccsds_27_bb_sptr"""
    return _fec_swig.encode_ccsds_27_bb_make()

class ber_bf(object):
    r"""Proxy of C++ gr::fec::ber_bf 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 total_errors(self) -> "long":
        r"""total_errors(ber_bf self) -> long"""
        return _fec_swig.ber_bf_total_errors(self)

    @staticmethod
    def make(test_mode: "bool"=False, berminerrors: "int"=100, ber_limit: "float"=-7.0) -> "gr::fec::ber_bf::sptr":
        r"""make(bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
        return _fec_swig.ber_bf_make(test_mode, berminerrors, ber_limit)
    __swig_destroy__ = _fec_swig.delete_ber_bf

# Register ber_bf in _fec_swig:
_fec_swig.ber_bf_swigregister(ber_bf)

def ber_bf_make(test_mode: "bool"=False, berminerrors: "int"=100, ber_limit: "float"=-7.0) -> "gr::fec::ber_bf::sptr":
    r"""ber_bf_make(bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
    return _fec_swig.ber_bf_make(test_mode, berminerrors, ber_limit)

class conv_bit_corr_bb(object):
    r"""Proxy of C++ gr::fec::conv_bit_corr_bb class."""

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

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

    @staticmethod
    def make(correlator: "std::vector< unsigned long long,std::allocator< unsigned long long > >", corr_sym: "int", corr_len: "int", cut: "int", flush: "int", thresh: "float") -> "gr::fec::conv_bit_corr_bb::sptr":
        r"""make(std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
        return _fec_swig.conv_bit_corr_bb_make(correlator, corr_sym, corr_len, cut, flush, thresh)

    def data_garble_rate(self, taps: "int", syn_density: "float") -> "float":
        r"""data_garble_rate(conv_bit_corr_bb self, int taps, float syn_density) -> float"""
        return _fec_swig.conv_bit_corr_bb_data_garble_rate(self, taps, syn_density)
    __swig_destroy__ = _fec_swig.delete_conv_bit_corr_bb

# Register conv_bit_corr_bb in _fec_swig:
_fec_swig.conv_bit_corr_bb_swigregister(conv_bit_corr_bb)

def conv_bit_corr_bb_make(correlator: "std::vector< unsigned long long,std::allocator< unsigned long long > >", corr_sym: "int", corr_len: "int", cut: "int", flush: "int", thresh: "float") -> "gr::fec::conv_bit_corr_bb::sptr":
    r"""conv_bit_corr_bb_make(std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
    return _fec_swig.conv_bit_corr_bb_make(correlator, corr_sym, corr_len, cut, flush, thresh)

class puncture_bb(object):
    r"""Proxy of C++ gr::fec::puncture_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(puncsize: "int", puncpat: "int", delay: "int"=0) -> "gr::fec::puncture_bb::sptr":
        r"""make(int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
        return _fec_swig.puncture_bb_make(puncsize, puncpat, delay)
    __swig_destroy__ = _fec_swig.delete_puncture_bb

# Register puncture_bb in _fec_swig:
_fec_swig.puncture_bb_swigregister(puncture_bb)

def puncture_bb_make(puncsize: "int", puncpat: "int", delay: "int"=0) -> "gr::fec::puncture_bb::sptr":
    r"""puncture_bb_make(int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
    return _fec_swig.puncture_bb_make(puncsize, puncpat, delay)

class puncture_ff(object):
    r"""Proxy of C++ gr::fec::puncture_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(puncsize: "int", puncpat: "int", delay: "int") -> "gr::fec::puncture_ff::sptr":
        r"""make(int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
        return _fec_swig.puncture_ff_make(puncsize, puncpat, delay)
    __swig_destroy__ = _fec_swig.delete_puncture_ff

# Register puncture_ff in _fec_swig:
_fec_swig.puncture_ff_swigregister(puncture_ff)

def puncture_ff_make(puncsize: "int", puncpat: "int", delay: "int") -> "gr::fec::puncture_ff::sptr":
    r"""puncture_ff_make(int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
    return _fec_swig.puncture_ff_make(puncsize, puncpat, delay)

class depuncture_bb(object):
    r"""Proxy of C++ gr::fec::depuncture_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(puncsize: "int", puncpat: "int", delay: "int"=0, symbol: "char"=127) -> "gr::fec::depuncture_bb::sptr":
        r"""make(int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
        return _fec_swig.depuncture_bb_make(puncsize, puncpat, delay, symbol)
    __swig_destroy__ = _fec_swig.delete_depuncture_bb

# Register depuncture_bb in _fec_swig:
_fec_swig.depuncture_bb_swigregister(depuncture_bb)

def depuncture_bb_make(puncsize: "int", puncpat: "int", delay: "int"=0, symbol: "char"=127) -> "gr::fec::depuncture_bb::sptr":
    r"""depuncture_bb_make(int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
    return _fec_swig.depuncture_bb_make(puncsize, puncpat, delay, symbol)

class tpc_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::tpc_encoder 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
    __swig_destroy__ = _fec_swig.delete_tpc_encoder

    @staticmethod
    def make(row_poly: "std::vector< int,std::allocator< int > >", col_poly: "std::vector< int,std::allocator< int > >", krow: "int", kcol: "int", bval: "int", qval: "int") -> "gr::fec::generic_encoder::sptr":
        r"""make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval) -> generic_encoder_sptr"""
        return _fec_swig.tpc_encoder_make(row_poly, col_poly, krow, kcol, bval, qval)

# Register tpc_encoder in _fec_swig:
_fec_swig.tpc_encoder_swigregister(tpc_encoder)

def tpc_encoder_make(row_poly: "std::vector< int,std::allocator< int > >", col_poly: "std::vector< int,std::allocator< int > >", krow: "int", kcol: "int", bval: "int", qval: "int") -> "gr::fec::generic_encoder::sptr":
    r"""tpc_encoder_make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval) -> generic_encoder_sptr"""
    return _fec_swig.tpc_encoder_make(row_poly, col_poly, krow, kcol, bval, qval)

MAXLOG = _fec_swig.MAXLOG

class tpc_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::tpc_decoder 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(row_poly: "std::vector< int,std::allocator< int > >", col_poly: "std::vector< int,std::allocator< int > >", krow: "int", kcol: "int", bval: "int", qval: "int", max_iter: "int", decoder_type: "int") -> "gr::fec::generic_decoder::sptr":
        r"""make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval, int max_iter, int decoder_type) -> generic_decoder_sptr"""
        return _fec_swig.tpc_decoder_make(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type)
    __swig_destroy__ = _fec_swig.delete_tpc_decoder

# Register tpc_decoder in _fec_swig:
_fec_swig.tpc_decoder_swigregister(tpc_decoder)

def tpc_decoder_make(row_poly: "std::vector< int,std::allocator< int > >", col_poly: "std::vector< int,std::allocator< int > >", krow: "int", kcol: "int", bval: "int", qval: "int", max_iter: "int", decoder_type: "int") -> "gr::fec::generic_decoder::sptr":
    r"""tpc_decoder_make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval, int max_iter, int decoder_type) -> generic_decoder_sptr"""
    return _fec_swig.tpc_decoder_make(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type)

class polar_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::polar_encoder 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(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >", is_packed: "bool"=False) -> "gr::fec::generic_encoder::sptr":
        r"""make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values, bool is_packed=False) -> generic_encoder_sptr"""
        return _fec_swig.polar_encoder_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed)
    __swig_destroy__ = _fec_swig.delete_polar_encoder

# Register polar_encoder in _fec_swig:
_fec_swig.polar_encoder_swigregister(polar_encoder)

def polar_encoder_make(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >", is_packed: "bool"=False) -> "gr::fec::generic_encoder::sptr":
    r"""polar_encoder_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values, bool is_packed=False) -> generic_encoder_sptr"""
    return _fec_swig.polar_encoder_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed)

class polar_decoder_sc(object):
    r"""Proxy of C++ gr::fec::code::polar_decoder_sc 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(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >") -> "gr::fec::generic_decoder::sptr":
        r"""make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc

    def generic_work(self, in_buffer: "void *", out_buffer: "void *") -> "void":
        r"""generic_work(polar_decoder_sc self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.polar_decoder_sc_generic_work(self, in_buffer, out_buffer)

# Register polar_decoder_sc in _fec_swig:
_fec_swig.polar_decoder_sc_swigregister(polar_decoder_sc)

def polar_decoder_sc_make(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >") -> "gr::fec::generic_decoder::sptr":
    r"""polar_decoder_sc_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

class polar_common(object):
    r"""Proxy of C++ gr::fec::code::polar_common 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, block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >"):
        r"""__init__(polar_common self, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> polar_common"""
        _fec_swig.polar_common_swiginit(self, _fec_swig.new_polar_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values))
    __swig_destroy__ = _fec_swig.delete_polar_common

# Register polar_common in _fec_swig:
_fec_swig.polar_common_swigregister(polar_common)

class polar_decoder_sc_list(object):
    r"""Proxy of C++ gr::fec::code::polar_decoder_sc_list 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(max_list_size: "int", block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >") -> "gr::fec::generic_decoder::sptr":
        r"""make(int max_list_size, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_list_make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc_list

    def generic_work(self, in_buffer: "void *", out_buffer: "void *") -> "void":
        r"""generic_work(polar_decoder_sc_list self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.polar_decoder_sc_list_generic_work(self, in_buffer, out_buffer)

# Register polar_decoder_sc_list in _fec_swig:
_fec_swig.polar_decoder_sc_list_swigregister(polar_decoder_sc_list)

def polar_decoder_sc_list_make(max_list_size: "int", block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >", frozen_bit_values: "std::vector< char,std::allocator< char > >") -> "gr::fec::generic_decoder::sptr":
    r"""polar_decoder_sc_list_make(int max_list_size, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_list_make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

class polar_decoder_common(generic_decoder, polar_common):
    r"""Proxy of C++ gr::fec::code::polar_decoder_common 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
    __swig_destroy__ = _fec_swig.delete_polar_decoder_common

# Register polar_decoder_common in _fec_swig:
_fec_swig.polar_decoder_common_swigregister(polar_decoder_common)

class polar_encoder_systematic(generic_encoder, polar_common):
    r"""Proxy of C++ gr::fec::code::polar_encoder_systematic 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(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >") -> "gr::fec::generic_encoder::sptr":
        r"""make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_encoder_sptr"""
        return _fec_swig.polar_encoder_systematic_make(block_size, num_info_bits, frozen_bit_positions)
    __swig_destroy__ = _fec_swig.delete_polar_encoder_systematic

# Register polar_encoder_systematic in _fec_swig:
_fec_swig.polar_encoder_systematic_swigregister(polar_encoder_systematic)

def polar_encoder_systematic_make(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >") -> "gr::fec::generic_encoder::sptr":
    r"""polar_encoder_systematic_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_encoder_sptr"""
    return _fec_swig.polar_encoder_systematic_make(block_size, num_info_bits, frozen_bit_positions)

class polar_decoder_sc_systematic(polar_decoder_common):
    r"""Proxy of C++ gr::fec::code::polar_decoder_sc_systematic 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(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >") -> "gr::fec::generic_decoder::sptr":
        r"""make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_systematic_make(block_size, num_info_bits, frozen_bit_positions)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc_systematic

# Register polar_decoder_sc_systematic in _fec_swig:
_fec_swig.polar_decoder_sc_systematic_swigregister(polar_decoder_sc_systematic)

def polar_decoder_sc_systematic_make(block_size: "int", num_info_bits: "int", frozen_bit_positions: "std::vector< int,std::allocator< int > >") -> "gr::fec::generic_decoder::sptr":
    r"""polar_decoder_sc_systematic_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_systematic_make(block_size, num_info_bits, frozen_bit_positions)

class ldpc_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::ldpc_encoder 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(alist_file: "std::string") -> "gr::fec::generic_encoder::sptr":
        r"""make(std::string alist_file) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_encoder_make(alist_file)
    __swig_destroy__ = _fec_swig.delete_ldpc_encoder

# Register ldpc_encoder in _fec_swig:
_fec_swig.ldpc_encoder_swigregister(ldpc_encoder)

def ldpc_encoder_make(alist_file: "std::string") -> "gr::fec::generic_encoder::sptr":
    r"""ldpc_encoder_make(std::string alist_file) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_encoder_make(alist_file)

class block_data(object):
    r"""Proxy of C++ gr::fec::code::block_data class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_fec_swig.block_data_size_get, _fec_swig.block_data_size_set, doc=r"""size : size_t""")
    data = property(_fec_swig.block_data_data_get, _fec_swig.block_data_data_set, doc=r"""data : p.double""")

    def __init__(self):
        r"""__init__(block_data self) -> block_data"""
        _fec_swig.block_data_swiginit(self, _fec_swig.new_block_data())
    __swig_destroy__ = _fec_swig.delete_block_data

# Register block_data in _fec_swig:
_fec_swig.block_data_swigregister(block_data)

class matrix(object):
    r"""Proxy of C++ gr::fec::code::matrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size1 = property(_fec_swig.matrix_size1_get, _fec_swig.matrix_size1_set, doc=r"""size1 : size_t""")
    size2 = property(_fec_swig.matrix_size2_get, _fec_swig.matrix_size2_set, doc=r"""size2 : size_t""")
    tda = property(_fec_swig.matrix_tda_get, _fec_swig.matrix_tda_set, doc=r"""tda : size_t""")
    data = property(_fec_swig.matrix_data_get, _fec_swig.matrix_data_set, doc=r"""data : p.double""")
    block = property(_fec_swig.matrix_block_get, _fec_swig.matrix_block_set, doc=r"""block : p.gr::fec::code::block_data""")
    owner = property(_fec_swig.matrix_owner_get, _fec_swig.matrix_owner_set, doc=r"""owner : int""")

    def __init__(self):
        r"""__init__(matrix self) -> matrix"""
        _fec_swig.matrix_swiginit(self, _fec_swig.new_matrix())
    __swig_destroy__ = _fec_swig.delete_matrix

# Register matrix in _fec_swig:
_fec_swig.matrix_swigregister(matrix)


def matrix_free(x: "matrix") -> "void":
    r"""matrix_free(matrix x)"""
    return _fec_swig.matrix_free(x)

def read_matrix_from_file(filename: "std::string const") -> "gr::fec::code::matrix_sptr":
    r"""read_matrix_from_file(std::string const filename) -> matrix_sptr"""
    return _fec_swig.read_matrix_from_file(filename)

def write_matrix_to_file(filename: "std::string const", M: "matrix_sptr") -> "void":
    r"""write_matrix_to_file(std::string const filename, matrix_sptr M)"""
    return _fec_swig.write_matrix_to_file(filename, M)

def generate_G_transpose(H_obj: "matrix_sptr") -> "gr::fec::code::matrix_sptr":
    r"""generate_G_transpose(matrix_sptr H_obj) -> matrix_sptr"""
    return _fec_swig.generate_G_transpose(H_obj)

def generate_G(H_obj: "matrix_sptr") -> "gr::fec::code::matrix_sptr":
    r"""generate_G(matrix_sptr H_obj) -> matrix_sptr"""
    return _fec_swig.generate_G(H_obj)

def generate_H(G_obj: "matrix_sptr") -> "gr::fec::code::matrix_sptr":
    r"""generate_H(matrix_sptr G_obj) -> matrix_sptr"""
    return _fec_swig.generate_H(G_obj)

def print_matrix(M: "matrix_sptr", numpy: "bool"=False) -> "void":
    r"""print_matrix(matrix_sptr M, bool numpy=False)"""
    return _fec_swig.print_matrix(M, numpy)
class fec_mtrx(object):
    r"""Proxy of C++ gr::fec::code::fec_mtrx 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
    __swig_destroy__ = _fec_swig.delete_fec_mtrx

    def encode(self, outbuffer: "unsigned char *", inbuffer: "unsigned char const *") -> "void":
        r"""encode(fec_mtrx self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.fec_mtrx_encode(self, outbuffer, inbuffer)

    def decode(self, outbuffer: "unsigned char *", inbuffer: "float const *", frame_size: "unsigned int", max_iterations: "unsigned int") -> "void":
        r"""decode(fec_mtrx self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.fec_mtrx_decode(self, outbuffer, inbuffer, frame_size, max_iterations)

    def n(self) -> "unsigned int":
        r"""n(fec_mtrx self) -> unsigned int"""
        return _fec_swig.fec_mtrx_n(self)

    def k(self) -> "unsigned int":
        r"""k(fec_mtrx self) -> unsigned int"""
        return _fec_swig.fec_mtrx_k(self)

# Register fec_mtrx in _fec_swig:
_fec_swig.fec_mtrx_swigregister(fec_mtrx)

class ldpc_H_matrix(fec_mtrx):
    r"""Proxy of C++ gr::fec::code::ldpc_H_matrix 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(filename: "std::string const", gap: "unsigned int") -> "gr::fec::code::ldpc_H_matrix::sptr":
        r"""make(std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
        return _fec_swig.ldpc_H_matrix_make(filename, gap)

    def get_base_sptr(self) -> "gr::fec::code::fec_mtrx_sptr":
        r"""get_base_sptr(ldpc_H_matrix self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_H_matrix_get_base_sptr(self)
    __swig_destroy__ = _fec_swig.delete_ldpc_H_matrix

# Register ldpc_H_matrix in _fec_swig:
_fec_swig.ldpc_H_matrix_swigregister(ldpc_H_matrix)

def ldpc_H_matrix_make(filename: "std::string const", gap: "unsigned int") -> "gr::fec::code::ldpc_H_matrix::sptr":
    r"""ldpc_H_matrix_make(std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
    return _fec_swig.ldpc_H_matrix_make(filename, gap)

class ldpc_G_matrix(fec_mtrx):
    r"""Proxy of C++ gr::fec::code::ldpc_G_matrix 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(filename: "std::string const") -> "gr::fec::code::ldpc_G_matrix::sptr":
        r"""make(std::string const filename) -> ldpc_G_matrix_sptr"""
        return _fec_swig.ldpc_G_matrix_make(filename)

    def get_base_sptr(self) -> "gr::fec::code::fec_mtrx_sptr":
        r"""get_base_sptr(ldpc_G_matrix self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_G_matrix_get_base_sptr(self)
    __swig_destroy__ = _fec_swig.delete_ldpc_G_matrix

# Register ldpc_G_matrix in _fec_swig:
_fec_swig.ldpc_G_matrix_swigregister(ldpc_G_matrix)

def ldpc_G_matrix_make(filename: "std::string const") -> "gr::fec::code::ldpc_G_matrix::sptr":
    r"""ldpc_G_matrix_make(std::string const filename) -> ldpc_G_matrix_sptr"""
    return _fec_swig.ldpc_G_matrix_make(filename)

class ldpc_gen_mtrx_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::ldpc_gen_mtrx_encoder 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(G_obj: "ldpc_G_matrix_sptr") -> "gr::fec::generic_encoder::sptr":
        r"""make(ldpc_G_matrix_sptr G_obj) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_gen_mtrx_encoder_make(G_obj)
    __swig_destroy__ = _fec_swig.delete_ldpc_gen_mtrx_encoder

# Register ldpc_gen_mtrx_encoder in _fec_swig:
_fec_swig.ldpc_gen_mtrx_encoder_swigregister(ldpc_gen_mtrx_encoder)

def ldpc_gen_mtrx_encoder_make(G_obj: "ldpc_G_matrix_sptr") -> "gr::fec::generic_encoder::sptr":
    r"""ldpc_gen_mtrx_encoder_make(ldpc_G_matrix_sptr G_obj) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_gen_mtrx_encoder_make(G_obj)

class ldpc_par_mtrx_encoder(generic_encoder):
    r"""Proxy of C++ gr::fec::code::ldpc_par_mtrx_encoder 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(alist_file: "std::string", gap: "unsigned int"=0) -> "gr::fec::generic_encoder::sptr":
        r"""make(std::string alist_file, unsigned int gap=0) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_par_mtrx_encoder_make(alist_file, gap)

    @staticmethod
    def make_H(H_obj: "ldpc_H_matrix_sptr") -> "gr::fec::generic_encoder::sptr":
        r"""make_H(ldpc_H_matrix_sptr H_obj) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_par_mtrx_encoder_make_H(H_obj)
    __swig_destroy__ = _fec_swig.delete_ldpc_par_mtrx_encoder

# Register ldpc_par_mtrx_encoder in _fec_swig:
_fec_swig.ldpc_par_mtrx_encoder_swigregister(ldpc_par_mtrx_encoder)

def ldpc_par_mtrx_encoder_make(alist_file: "std::string", gap: "unsigned int"=0) -> "gr::fec::generic_encoder::sptr":
    r"""ldpc_par_mtrx_encoder_make(std::string alist_file, unsigned int gap=0) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_par_mtrx_encoder_make(alist_file, gap)

def ldpc_par_mtrx_encoder_make_H(H_obj: "ldpc_H_matrix_sptr") -> "gr::fec::generic_encoder::sptr":
    r"""ldpc_par_mtrx_encoder_make_H(ldpc_H_matrix_sptr H_obj) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_par_mtrx_encoder_make_H(H_obj)

class ldpc_bit_flip_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::code::ldpc_bit_flip_decoder 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(mtrx_obj: "fec_mtrx_sptr", max_iter: "unsigned int"=100) -> "gr::fec::generic_decoder::sptr":
        r"""make(fec_mtrx_sptr mtrx_obj, unsigned int max_iter=100) -> generic_decoder_sptr"""
        return _fec_swig.ldpc_bit_flip_decoder_make(mtrx_obj, max_iter)
    __swig_destroy__ = _fec_swig.delete_ldpc_bit_flip_decoder

# Register ldpc_bit_flip_decoder in _fec_swig:
_fec_swig.ldpc_bit_flip_decoder_swigregister(ldpc_bit_flip_decoder)

def ldpc_bit_flip_decoder_make(mtrx_obj: "fec_mtrx_sptr", max_iter: "unsigned int"=100) -> "gr::fec::generic_decoder::sptr":
    r"""ldpc_bit_flip_decoder_make(fec_mtrx_sptr mtrx_obj, unsigned int max_iter=100) -> generic_decoder_sptr"""
    return _fec_swig.ldpc_bit_flip_decoder_make(mtrx_obj, max_iter)

class ldpc_decoder(generic_decoder):
    r"""Proxy of C++ gr::fec::ldpc_decoder 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
    __swig_destroy__ = _fec_swig.delete_ldpc_decoder

    @staticmethod
    def make(alist_file: "std::string", sigma: "float"=0.5, max_iterations: "int"=50) -> "gr::fec::generic_decoder::sptr":
        r"""make(std::string alist_file, float sigma=0.5, int max_iterations=50) -> generic_decoder_sptr"""
        return _fec_swig.ldpc_decoder_make(alist_file, sigma, max_iterations)

# Register ldpc_decoder in _fec_swig:
_fec_swig.ldpc_decoder_swigregister(ldpc_decoder)

def ldpc_decoder_make(alist_file: "std::string", sigma: "float"=0.5, max_iterations: "int"=50) -> "gr::fec::generic_decoder::sptr":
    r"""ldpc_decoder_make(std::string alist_file, float sigma=0.5, int max_iterations=50) -> generic_decoder_sptr"""
    return _fec_swig.ldpc_decoder_make(alist_file, sigma, max_iterations)

class matrix_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::code::matrix > 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__(matrix_sptr self) -> matrix_sptr
        __init__(matrix_sptr self, matrix p) -> matrix_sptr
        """
        _fec_swig.matrix_sptr_swiginit(self, _fec_swig.new_matrix_sptr(*args))

    def __deref__(self) -> "gr::fec::code::matrix *":
        r"""__deref__(matrix_sptr self) -> matrix"""
        return _fec_swig.matrix_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_matrix_sptr
    size1 = property(_fec_swig.matrix_sptr_size1_get, _fec_swig.matrix_sptr_size1_set, doc=r"""size1 : size_t""")
    size2 = property(_fec_swig.matrix_sptr_size2_get, _fec_swig.matrix_sptr_size2_set, doc=r"""size2 : size_t""")
    tda = property(_fec_swig.matrix_sptr_tda_get, _fec_swig.matrix_sptr_tda_set, doc=r"""tda : size_t""")
    data = property(_fec_swig.matrix_sptr_data_get, _fec_swig.matrix_sptr_data_set, doc=r"""data : p.double""")
    block = property(_fec_swig.matrix_sptr_block_get, _fec_swig.matrix_sptr_block_set, doc=r"""block : p.gr::fec::code::block_data""")
    owner = property(_fec_swig.matrix_sptr_owner_get, _fec_swig.matrix_sptr_owner_set, doc=r"""owner : int""")

# Register matrix_sptr in _fec_swig:
_fec_swig.matrix_sptr_swigregister(matrix_sptr)

class fec_mtrx_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::code::fec_mtrx > 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__(fec_mtrx_sptr self) -> fec_mtrx_sptr
        __init__(fec_mtrx_sptr self, fec_mtrx p) -> fec_mtrx_sptr
        """
        _fec_swig.fec_mtrx_sptr_swiginit(self, _fec_swig.new_fec_mtrx_sptr(*args))

    def __deref__(self) -> "gr::fec::code::fec_mtrx *":
        r"""__deref__(fec_mtrx_sptr self) -> fec_mtrx"""
        return _fec_swig.fec_mtrx_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_fec_mtrx_sptr

    def encode(self, outbuffer: "unsigned char *", inbuffer: "unsigned char const *") -> "void":
        r"""encode(fec_mtrx_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.fec_mtrx_sptr_encode(self, outbuffer, inbuffer)

    def decode(self, outbuffer: "unsigned char *", inbuffer: "float const *", frame_size: "unsigned int", max_iterations: "unsigned int") -> "void":
        r"""decode(fec_mtrx_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.fec_mtrx_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)

    def n(self) -> "unsigned int":
        r"""n(fec_mtrx_sptr self) -> unsigned int"""
        return _fec_swig.fec_mtrx_sptr_n(self)

    def k(self) -> "unsigned int":
        r"""k(fec_mtrx_sptr self) -> unsigned int"""
        return _fec_swig.fec_mtrx_sptr_k(self)

# Register fec_mtrx_sptr in _fec_swig:
_fec_swig.fec_mtrx_sptr_swigregister(fec_mtrx_sptr)

class ldpc_H_matrix_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::code::ldpc_H_matrix > 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__(ldpc_H_matrix_sptr self) -> ldpc_H_matrix_sptr
        __init__(ldpc_H_matrix_sptr self, ldpc_H_matrix p) -> ldpc_H_matrix_sptr
        """
        _fec_swig.ldpc_H_matrix_sptr_swiginit(self, _fec_swig.new_ldpc_H_matrix_sptr(*args))

    def __deref__(self) -> "gr::fec::code::ldpc_H_matrix *":
        r"""__deref__(ldpc_H_matrix_sptr self) -> ldpc_H_matrix"""
        return _fec_swig.ldpc_H_matrix_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_ldpc_H_matrix_sptr

    def make(self, filename: "std::string const", gap: "unsigned int") -> "gr::fec::code::ldpc_H_matrix::sptr":
        r"""make(ldpc_H_matrix_sptr self, std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
        return _fec_swig.ldpc_H_matrix_sptr_make(self, filename, gap)

    def get_base_sptr(self) -> "gr::fec::code::fec_mtrx_sptr":
        r"""get_base_sptr(ldpc_H_matrix_sptr self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_H_matrix_sptr_get_base_sptr(self)

    def encode(self, outbuffer: "unsigned char *", inbuffer: "unsigned char const *") -> "void":
        r"""encode(ldpc_H_matrix_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.ldpc_H_matrix_sptr_encode(self, outbuffer, inbuffer)

    def decode(self, outbuffer: "unsigned char *", inbuffer: "float const *", frame_size: "unsigned int", max_iterations: "unsigned int") -> "void":
        r"""decode(ldpc_H_matrix_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.ldpc_H_matrix_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)

    def n(self) -> "unsigned int":
        r"""n(ldpc_H_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_H_matrix_sptr_n(self)

    def k(self) -> "unsigned int":
        r"""k(ldpc_H_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_H_matrix_sptr_k(self)

# Register ldpc_H_matrix_sptr in _fec_swig:
_fec_swig.ldpc_H_matrix_sptr_swigregister(ldpc_H_matrix_sptr)


ldpc_H_matrix = ldpc_H_matrix.make;

class ldpc_G_matrix_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::code::ldpc_G_matrix > 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__(ldpc_G_matrix_sptr self) -> ldpc_G_matrix_sptr
        __init__(ldpc_G_matrix_sptr self, ldpc_G_matrix p) -> ldpc_G_matrix_sptr
        """
        _fec_swig.ldpc_G_matrix_sptr_swiginit(self, _fec_swig.new_ldpc_G_matrix_sptr(*args))

    def __deref__(self) -> "gr::fec::code::ldpc_G_matrix *":
        r"""__deref__(ldpc_G_matrix_sptr self) -> ldpc_G_matrix"""
        return _fec_swig.ldpc_G_matrix_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_ldpc_G_matrix_sptr

    def make(self, filename: "std::string const") -> "gr::fec::code::ldpc_G_matrix::sptr":
        r"""make(ldpc_G_matrix_sptr self, std::string const filename) -> ldpc_G_matrix_sptr"""
        return _fec_swig.ldpc_G_matrix_sptr_make(self, filename)

    def get_base_sptr(self) -> "gr::fec::code::fec_mtrx_sptr":
        r"""get_base_sptr(ldpc_G_matrix_sptr self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_G_matrix_sptr_get_base_sptr(self)

    def encode(self, outbuffer: "unsigned char *", inbuffer: "unsigned char const *") -> "void":
        r"""encode(ldpc_G_matrix_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.ldpc_G_matrix_sptr_encode(self, outbuffer, inbuffer)

    def decode(self, outbuffer: "unsigned char *", inbuffer: "float const *", frame_size: "unsigned int", max_iterations: "unsigned int") -> "void":
        r"""decode(ldpc_G_matrix_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.ldpc_G_matrix_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)

    def n(self) -> "unsigned int":
        r"""n(ldpc_G_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_G_matrix_sptr_n(self)

    def k(self) -> "unsigned int":
        r"""k(ldpc_G_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_G_matrix_sptr_k(self)

# Register ldpc_G_matrix_sptr in _fec_swig:
_fec_swig.ldpc_G_matrix_sptr_swigregister(ldpc_G_matrix_sptr)


ldpc_G_matrix = ldpc_G_matrix.make;

class decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::decoder > 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__(decoder_sptr self) -> decoder_sptr
        __init__(decoder_sptr self, decoder p) -> decoder_sptr
        """
        _fec_swig.decoder_sptr_swiginit(self, _fec_swig.new_decoder_sptr(*args))

    def __deref__(self) -> "gr::fec::decoder *":
        r"""__deref__(decoder_sptr self) -> decoder"""
        return _fec_swig.decoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_decoder_sptr

    def make(self, my_decoder: "generic_decoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::decoder::sptr":
        r"""make(decoder_sptr self, generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
        return _fec_swig.decoder_sptr_make(self, my_decoder, input_item_size, output_item_size)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.decoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def fixed_rate_ninput_to_noutput(self, ninput: "int") -> "int":
        r"""fixed_rate_ninput_to_noutput(decoder_sptr self, int ninput) -> int"""
        return _fec_swig.decoder_sptr_fixed_rate_ninput_to_noutput(self, ninput)

    def fixed_rate_noutput_to_ninput(self, noutput: "int") -> "int":
        r"""fixed_rate_noutput_to_ninput(decoder_sptr self, int noutput) -> int"""
        return _fec_swig.decoder_sptr_fixed_rate_noutput_to_ninput(self, noutput)

    def forecast(self, noutput_items: "int", ninput_items_required: "gr_vector_int &") -> "void":
        r"""forecast(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.decoder_sptr_forecast(self, noutput_items, ninput_items_required)

    def history(self) -> "unsigned int":
        r"""history(decoder_sptr self) -> unsigned int"""
        return _fec_swig.decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(decoder_sptr self, int which, int delay)
        declare_sample_delay(decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(decoder_sptr self, int multiple)"""
        return _fec_swig.decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(decoder_sptr self) -> double"""
        return _fec_swig.decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(decoder_sptr self) -> uint64_t"""
        return _fec_swig.decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(decoder_sptr self) -> uint64_t"""
        return _fec_swig.decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(decoder_sptr self, std::string level)"""
        return _fec_swig.decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(decoder_sptr self, int m)"""
        return _fec_swig.decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(decoder_sptr self)"""
        return _fec_swig.decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(decoder_sptr self, int m)"""
        return _fec_swig.decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(decoder_sptr self, int i) -> long"""
        return _fec_swig.decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(decoder_sptr self, int i) -> long"""
        return _fec_swig.decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(decoder_sptr self)"""
        return _fec_swig.decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(decoder_sptr self, int priority) -> int"""
        return _fec_swig.decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(decoder_sptr self) -> long"""
        return _fec_swig.decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(decoder_sptr self, std::string name)"""
        return _fec_swig.decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.decoder_sptr_message_subscribers(self, which_port)

# Register decoder_sptr in _fec_swig:
_fec_swig.decoder_sptr_swigregister(decoder_sptr)


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

class encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::encoder > 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__(encoder_sptr self) -> encoder_sptr
        __init__(encoder_sptr self, encoder p) -> encoder_sptr
        """
        _fec_swig.encoder_sptr_swiginit(self, _fec_swig.new_encoder_sptr(*args))

    def __deref__(self) -> "gr::fec::encoder *":
        r"""__deref__(encoder_sptr self) -> encoder"""
        return _fec_swig.encoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_encoder_sptr

    def make(self, my_encoder: "generic_encoder_sptr", input_item_size: "size_t", output_item_size: "size_t") -> "gr::fec::encoder::sptr":
        r"""make(encoder_sptr self, generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
        return _fec_swig.encoder_sptr_make(self, my_encoder, input_item_size, output_item_size)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.encoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def fixed_rate_ninput_to_noutput(self, ninput: "int") -> "int":
        r"""fixed_rate_ninput_to_noutput(encoder_sptr self, int ninput) -> int"""
        return _fec_swig.encoder_sptr_fixed_rate_ninput_to_noutput(self, ninput)

    def fixed_rate_noutput_to_ninput(self, noutput: "int") -> "int":
        r"""fixed_rate_noutput_to_ninput(encoder_sptr self, int noutput) -> int"""
        return _fec_swig.encoder_sptr_fixed_rate_noutput_to_ninput(self, noutput)

    def forecast(self, noutput_items: "int", ninput_items_required: "gr_vector_int &") -> "void":
        r"""forecast(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.encoder_sptr_forecast(self, noutput_items, ninput_items_required)

    def history(self) -> "unsigned int":
        r"""history(encoder_sptr self) -> unsigned int"""
        return _fec_swig.encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(encoder_sptr self, int which, int delay)
        declare_sample_delay(encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(encoder_sptr self, int multiple)"""
        return _fec_swig.encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(encoder_sptr self) -> double"""
        return _fec_swig.encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(encoder_sptr self) -> uint64_t"""
        return _fec_swig.encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(encoder_sptr self) -> uint64_t"""
        return _fec_swig.encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(encoder_sptr self, std::string level)"""
        return _fec_swig.encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(encoder_sptr self, int m)"""
        return _fec_swig.encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(encoder_sptr self)"""
        return _fec_swig.encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(encoder_sptr self, int m)"""
        return _fec_swig.encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(encoder_sptr self, int i) -> long"""
        return _fec_swig.encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(encoder_sptr self, int i) -> long"""
        return _fec_swig.encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(encoder_sptr self)"""
        return _fec_swig.encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(encoder_sptr self, int priority) -> int"""
        return _fec_swig.encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(encoder_sptr self) -> long"""
        return _fec_swig.encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(encoder_sptr self, std::string name)"""
        return _fec_swig.encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.encoder_sptr_message_subscribers(self, which_port)

# Register encoder_sptr in _fec_swig:
_fec_swig.encoder_sptr_swigregister(encoder_sptr)


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

class tagged_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::tagged_decoder > 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_decoder_sptr self) -> tagged_decoder_sptr
        __init__(tagged_decoder_sptr self, tagged_decoder p) -> tagged_decoder_sptr
        """
        _fec_swig.tagged_decoder_sptr_swiginit(self, _fec_swig.new_tagged_decoder_sptr(*args))

    def __deref__(self) -> "gr::fec::tagged_decoder *":
        r"""__deref__(tagged_decoder_sptr self) -> tagged_decoder"""
        return _fec_swig.tagged_decoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_tagged_decoder_sptr

    def make(self, *args, **kwargs) -> "gr::fec::tagged_decoder::sptr":
        r"""make(tagged_decoder_sptr self, generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_decoder_sptr"""
        return _fec_swig.tagged_decoder_sptr_make(self, *args, **kwargs)

    def work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""work(tagged_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_decoder_sptr_work(self, noutput_items, ninput_items, input_items, output_items)

    def calculate_output_stream_length(self, ninput_items: "gr_vector_int const &") -> "int":
        r"""calculate_output_stream_length(tagged_decoder_sptr self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_decoder_sptr_calculate_output_stream_length(self, ninput_items)

    def history(self) -> "unsigned int":
        r"""history(tagged_decoder_sptr self) -> unsigned int"""
        return _fec_swig.tagged_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_decoder_sptr self, int which, int delay)
        declare_sample_delay(tagged_decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.tagged_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.tagged_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_decoder_sptr self, int multiple)"""
        return _fec_swig.tagged_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_decoder_sptr self) -> double"""
        return _fec_swig.tagged_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_decoder_sptr self) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_decoder_sptr self) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_decoder_sptr self, std::string level)"""
        return _fec_swig.tagged_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_decoder_sptr self, int m)"""
        return _fec_swig.tagged_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_decoder_sptr self)"""
        return _fec_swig.tagged_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_decoder_sptr self, int m)"""
        return _fec_swig.tagged_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_decoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.tagged_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_decoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.tagged_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_decoder_sptr self, int which) -> float
        pc_input_buffers_full(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_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_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_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_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_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_decoder_sptr self, int which) -> float
        pc_output_buffers_full(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_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_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_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_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.tagged_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_decoder_sptr self)"""
        return _fec_swig.tagged_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.tagged_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_decoder_sptr self, int priority) -> int"""
        return _fec_swig.tagged_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_decoder_sptr self) -> long"""
        return _fec_swig.tagged_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.tagged_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.tagged_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_decoder_sptr self, std::string name)"""
        return _fec_swig.tagged_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.tagged_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_subscribers(self, which_port)

# Register tagged_decoder_sptr in _fec_swig:
_fec_swig.tagged_decoder_sptr_swigregister(tagged_decoder_sptr)


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

class tagged_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::tagged_encoder > 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_encoder_sptr self) -> tagged_encoder_sptr
        __init__(tagged_encoder_sptr self, tagged_encoder p) -> tagged_encoder_sptr
        """
        _fec_swig.tagged_encoder_sptr_swiginit(self, _fec_swig.new_tagged_encoder_sptr(*args))

    def __deref__(self) -> "gr::fec::tagged_encoder *":
        r"""__deref__(tagged_encoder_sptr self) -> tagged_encoder"""
        return _fec_swig.tagged_encoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_tagged_encoder_sptr

    def make(self, *args, **kwargs) -> "gr::fec::tagged_encoder::sptr":
        r"""make(tagged_encoder_sptr self, generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname="packet_len", int mtu=1500) -> tagged_encoder_sptr"""
        return _fec_swig.tagged_encoder_sptr_make(self, *args, **kwargs)

    def work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""work(tagged_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_encoder_sptr_work(self, noutput_items, ninput_items, input_items, output_items)

    def calculate_output_stream_length(self, ninput_items: "gr_vector_int const &") -> "int":
        r"""calculate_output_stream_length(tagged_encoder_sptr self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_encoder_sptr_calculate_output_stream_length(self, ninput_items)

    def history(self) -> "unsigned int":
        r"""history(tagged_encoder_sptr self) -> unsigned int"""
        return _fec_swig.tagged_encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_encoder_sptr self, int which, int delay)
        declare_sample_delay(tagged_encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.tagged_encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.tagged_encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_encoder_sptr self, int multiple)"""
        return _fec_swig.tagged_encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_encoder_sptr self) -> double"""
        return _fec_swig.tagged_encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_encoder_sptr self) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_encoder_sptr self) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_encoder_sptr self, std::string level)"""
        return _fec_swig.tagged_encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_encoder_sptr self, int m)"""
        return _fec_swig.tagged_encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_encoder_sptr self)"""
        return _fec_swig.tagged_encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_encoder_sptr self, int m)"""
        return _fec_swig.tagged_encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_encoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.tagged_encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_encoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.tagged_encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tagged_encoder_sptr self, int which) -> float
        pc_input_buffers_full(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_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_encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_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_encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_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_encoder_sptr self, int which) -> float
        pc_output_buffers_full(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_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_encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_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_encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tagged_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.tagged_encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_encoder_sptr self)"""
        return _fec_swig.tagged_encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.tagged_encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_encoder_sptr self, int priority) -> int"""
        return _fec_swig.tagged_encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_encoder_sptr self) -> long"""
        return _fec_swig.tagged_encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.tagged_encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.tagged_encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_encoder_sptr self, std::string name)"""
        return _fec_swig.tagged_encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.tagged_encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_subscribers(self, which_port)

# Register tagged_encoder_sptr in _fec_swig:
_fec_swig.tagged_encoder_sptr_swigregister(tagged_encoder_sptr)


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

class async_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::async_decoder > 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__(async_decoder_sptr self) -> async_decoder_sptr
        __init__(async_decoder_sptr self, async_decoder p) -> async_decoder_sptr
        """
        _fec_swig.async_decoder_sptr_swiginit(self, _fec_swig.new_async_decoder_sptr(*args))

    def __deref__(self) -> "gr::fec::async_decoder *":
        r"""__deref__(async_decoder_sptr self) -> async_decoder"""
        return _fec_swig.async_decoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_async_decoder_sptr

    def make(self, my_decoder: "generic_decoder_sptr", packed: "bool"=False, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_decoder::sptr":
        r"""make(async_decoder_sptr self, generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
        return _fec_swig.async_decoder_sptr_make(self, my_decoder, packed, rev_pack, mtu)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(async_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_decoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def history(self) -> "unsigned int":
        r"""history(async_decoder_sptr self) -> unsigned int"""
        return _fec_swig.async_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(async_decoder_sptr self, int which, int delay)
        declare_sample_delay(async_decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.async_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(async_decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.async_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(async_decoder_sptr self, int multiple)"""
        return _fec_swig.async_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(async_decoder_sptr self) -> double"""
        return _fec_swig.async_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(async_decoder_sptr self) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(async_decoder_sptr self) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(async_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(async_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(async_decoder_sptr self, std::string level)"""
        return _fec_swig.async_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(async_decoder_sptr self, int m)"""
        return _fec_swig.async_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(async_decoder_sptr self)"""
        return _fec_swig.async_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(async_decoder_sptr self, int m)"""
        return _fec_swig.async_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(async_decoder_sptr self, int i) -> long"""
        return _fec_swig.async_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(async_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(async_decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.async_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(async_decoder_sptr self, int i) -> long"""
        return _fec_swig.async_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(async_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(async_decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.async_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(async_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.async_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(async_decoder_sptr self)"""
        return _fec_swig.async_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(async_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.async_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(async_decoder_sptr self, int priority) -> int"""
        return _fec_swig.async_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(async_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(async_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(async_decoder_sptr self) -> long"""
        return _fec_swig.async_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(async_decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.async_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(async_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.async_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(async_decoder_sptr self, std::string name)"""
        return _fec_swig.async_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(async_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.async_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(async_decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.async_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(async_decoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.async_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(async_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.async_decoder_sptr_message_subscribers(self, which_port)

# Register async_decoder_sptr in _fec_swig:
_fec_swig.async_decoder_sptr_swigregister(async_decoder_sptr)


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

class async_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::async_encoder > 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__(async_encoder_sptr self) -> async_encoder_sptr
        __init__(async_encoder_sptr self, async_encoder p) -> async_encoder_sptr
        """
        _fec_swig.async_encoder_sptr_swiginit(self, _fec_swig.new_async_encoder_sptr(*args))

    def __deref__(self) -> "gr::fec::async_encoder *":
        r"""__deref__(async_encoder_sptr self) -> async_encoder"""
        return _fec_swig.async_encoder_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_async_encoder_sptr

    def make(self, my_encoder: "generic_encoder_sptr", packed: "bool"=False, rev_unpack: "bool"=True, rev_pack: "bool"=True, mtu: "int"=1500) -> "gr::fec::async_encoder::sptr":
        r"""make(async_encoder_sptr self, generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
        return _fec_swig.async_encoder_sptr_make(self, my_encoder, packed, rev_unpack, rev_pack, mtu)

    def general_work(self, noutput_items: "int", ninput_items: "gr_vector_int &", input_items: "gr_vector_const_void_star &", output_items: "gr_vector_void_star &") -> "int":
        r"""general_work(async_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_encoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)

    def history(self) -> "unsigned int":
        r"""history(async_encoder_sptr self) -> unsigned int"""
        return _fec_swig.async_encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(async_encoder_sptr self, int which, int delay)
        declare_sample_delay(async_encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.async_encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(async_encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.async_encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(async_encoder_sptr self, int multiple)"""
        return _fec_swig.async_encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(async_encoder_sptr self) -> double"""
        return _fec_swig.async_encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(async_encoder_sptr self) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(async_encoder_sptr self) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(async_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(async_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(async_encoder_sptr self, std::string level)"""
        return _fec_swig.async_encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(async_encoder_sptr self, int m)"""
        return _fec_swig.async_encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(async_encoder_sptr self)"""
        return _fec_swig.async_encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(async_encoder_sptr self, int m)"""
        return _fec_swig.async_encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(async_encoder_sptr self, int i) -> long"""
        return _fec_swig.async_encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(async_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(async_encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.async_encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(async_encoder_sptr self, int i) -> long"""
        return _fec_swig.async_encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(async_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(async_encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.async_encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(async_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.async_encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(async_encoder_sptr self)"""
        return _fec_swig.async_encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(async_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.async_encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(async_encoder_sptr self, int priority) -> int"""
        return _fec_swig.async_encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(async_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(async_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(async_encoder_sptr self) -> long"""
        return _fec_swig.async_encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(async_encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.async_encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(async_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.async_encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(async_encoder_sptr self, std::string name)"""
        return _fec_swig.async_encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(async_encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.async_encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(async_encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.async_encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(async_encoder_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.async_encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(async_encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.async_encoder_sptr_message_subscribers(self, which_port)

# Register async_encoder_sptr in _fec_swig:
_fec_swig.async_encoder_sptr_swigregister(async_encoder_sptr)


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

class decode_ccsds_27_fb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::decode_ccsds_27_fb > 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__(decode_ccsds_27_fb_sptr self) -> decode_ccsds_27_fb_sptr
        __init__(decode_ccsds_27_fb_sptr self, decode_ccsds_27_fb p) -> decode_ccsds_27_fb_sptr
        """
        _fec_swig.decode_ccsds_27_fb_sptr_swiginit(self, _fec_swig.new_decode_ccsds_27_fb_sptr(*args))

    def __deref__(self) -> "gr::fec::decode_ccsds_27_fb *":
        r"""__deref__(decode_ccsds_27_fb_sptr self) -> decode_ccsds_27_fb"""
        return _fec_swig.decode_ccsds_27_fb_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_decode_ccsds_27_fb_sptr

    def make(self) -> "gr::fec::decode_ccsds_27_fb::sptr":
        r"""make(decode_ccsds_27_fb_sptr self) -> decode_ccsds_27_fb_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(decode_ccsds_27_fb_sptr self) -> unsigned int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(decode_ccsds_27_fb_sptr self, int which, int delay)
        declare_sample_delay(decode_ccsds_27_fb_sptr self, unsigned int delay)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(decode_ccsds_27_fb_sptr self, int which) -> unsigned int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(decode_ccsds_27_fb_sptr self, int multiple)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(decode_ccsds_27_fb_sptr self) -> double"""
        return _fec_swig.decode_ccsds_27_fb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(decode_ccsds_27_fb_sptr self) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(decode_ccsds_27_fb_sptr self) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(decode_ccsds_27_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(decode_ccsds_27_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(decode_ccsds_27_fb_sptr self, std::string level)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(decode_ccsds_27_fb_sptr self, int m)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(decode_ccsds_27_fb_sptr self)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(decode_ccsds_27_fb_sptr self, int m)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(decode_ccsds_27_fb_sptr self, int i) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(decode_ccsds_27_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(decode_ccsds_27_fb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(decode_ccsds_27_fb_sptr self, int i) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(decode_ccsds_27_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(decode_ccsds_27_fb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(decode_ccsds_27_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(decode_ccsds_27_fb_sptr self)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(decode_ccsds_27_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.decode_ccsds_27_fb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(decode_ccsds_27_fb_sptr self, int priority) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(decode_ccsds_27_fb_sptr self) -> io_signature_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(decode_ccsds_27_fb_sptr self) -> io_signature_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(decode_ccsds_27_fb_sptr self) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(decode_ccsds_27_fb_sptr self) -> basic_block_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(decode_ccsds_27_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(decode_ccsds_27_fb_sptr self, std::string name)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(decode_ccsds_27_fb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.decode_ccsds_27_fb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(decode_ccsds_27_fb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(decode_ccsds_27_fb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(decode_ccsds_27_fb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_subscribers(self, which_port)

# Register decode_ccsds_27_fb_sptr in _fec_swig:
_fec_swig.decode_ccsds_27_fb_sptr_swigregister(decode_ccsds_27_fb_sptr)


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

class encode_ccsds_27_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::encode_ccsds_27_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__(encode_ccsds_27_bb_sptr self) -> encode_ccsds_27_bb_sptr
        __init__(encode_ccsds_27_bb_sptr self, encode_ccsds_27_bb p) -> encode_ccsds_27_bb_sptr
        """
        _fec_swig.encode_ccsds_27_bb_sptr_swiginit(self, _fec_swig.new_encode_ccsds_27_bb_sptr(*args))

    def __deref__(self) -> "gr::fec::encode_ccsds_27_bb *":
        r"""__deref__(encode_ccsds_27_bb_sptr self) -> encode_ccsds_27_bb"""
        return _fec_swig.encode_ccsds_27_bb_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_encode_ccsds_27_bb_sptr

    def make(self) -> "gr::fec::encode_ccsds_27_bb::sptr":
        r"""make(encode_ccsds_27_bb_sptr self) -> encode_ccsds_27_bb_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(encode_ccsds_27_bb_sptr self) -> unsigned int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(encode_ccsds_27_bb_sptr self, int which, int delay)
        declare_sample_delay(encode_ccsds_27_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(encode_ccsds_27_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(encode_ccsds_27_bb_sptr self, int multiple)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(encode_ccsds_27_bb_sptr self) -> double"""
        return _fec_swig.encode_ccsds_27_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(encode_ccsds_27_bb_sptr self) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(encode_ccsds_27_bb_sptr self) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(encode_ccsds_27_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(encode_ccsds_27_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(encode_ccsds_27_bb_sptr self, std::string level)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(encode_ccsds_27_bb_sptr self, int m)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(encode_ccsds_27_bb_sptr self)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(encode_ccsds_27_bb_sptr self, int m)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(encode_ccsds_27_bb_sptr self, int i) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(encode_ccsds_27_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(encode_ccsds_27_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(encode_ccsds_27_bb_sptr self, int i) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(encode_ccsds_27_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(encode_ccsds_27_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(encode_ccsds_27_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(encode_ccsds_27_bb_sptr self)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(encode_ccsds_27_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.encode_ccsds_27_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(encode_ccsds_27_bb_sptr self, int priority) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(encode_ccsds_27_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(encode_ccsds_27_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(encode_ccsds_27_bb_sptr self) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(encode_ccsds_27_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(encode_ccsds_27_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(encode_ccsds_27_bb_sptr self, std::string name)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(encode_ccsds_27_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.encode_ccsds_27_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(encode_ccsds_27_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(encode_ccsds_27_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(encode_ccsds_27_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_subscribers(self, which_port)

# Register encode_ccsds_27_bb_sptr in _fec_swig:
_fec_swig.encode_ccsds_27_bb_sptr_swigregister(encode_ccsds_27_bb_sptr)


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

class ber_bf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::ber_bf > 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__(ber_bf_sptr self) -> ber_bf_sptr
        __init__(ber_bf_sptr self, ber_bf p) -> ber_bf_sptr
        """
        _fec_swig.ber_bf_sptr_swiginit(self, _fec_swig.new_ber_bf_sptr(*args))

    def __deref__(self) -> "gr::fec::ber_bf *":
        r"""__deref__(ber_bf_sptr self) -> ber_bf"""
        return _fec_swig.ber_bf_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_ber_bf_sptr

    def total_errors(self) -> "long":
        r"""total_errors(ber_bf_sptr self) -> long"""
        return _fec_swig.ber_bf_sptr_total_errors(self)

    def make(self, test_mode: "bool"=False, berminerrors: "int"=100, ber_limit: "float"=-7.0) -> "gr::fec::ber_bf::sptr":
        r"""make(ber_bf_sptr self, bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
        return _fec_swig.ber_bf_sptr_make(self, test_mode, berminerrors, ber_limit)

    def history(self) -> "unsigned int":
        r"""history(ber_bf_sptr self) -> unsigned int"""
        return _fec_swig.ber_bf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ber_bf_sptr self, int which, int delay)
        declare_sample_delay(ber_bf_sptr self, unsigned int delay)
        """
        return _fec_swig.ber_bf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ber_bf_sptr self, int which) -> unsigned int"""
        return _fec_swig.ber_bf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ber_bf_sptr self, int multiple)"""
        return _fec_swig.ber_bf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ber_bf_sptr self) -> double"""
        return _fec_swig.ber_bf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ber_bf_sptr self) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ber_bf_sptr self) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ber_bf_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ber_bf_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ber_bf_sptr self, std::string level)"""
        return _fec_swig.ber_bf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ber_bf_sptr self, int m)"""
        return _fec_swig.ber_bf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ber_bf_sptr self)"""
        return _fec_swig.ber_bf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ber_bf_sptr self, int m)"""
        return _fec_swig.ber_bf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ber_bf_sptr self, int i) -> long"""
        return _fec_swig.ber_bf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ber_bf_sptr self, long max_output_buffer)
        set_max_output_buffer(ber_bf_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.ber_bf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ber_bf_sptr self, int i) -> long"""
        return _fec_swig.ber_bf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ber_bf_sptr self, long min_output_buffer)
        set_min_output_buffer(ber_bf_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.ber_bf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ber_bf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.ber_bf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ber_bf_sptr self)"""
        return _fec_swig.ber_bf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ber_bf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.ber_bf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ber_bf_sptr self, int priority) -> int"""
        return _fec_swig.ber_bf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ber_bf_sptr self) -> io_signature_sptr"""
        return _fec_swig.ber_bf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ber_bf_sptr self) -> io_signature_sptr"""
        return _fec_swig.ber_bf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ber_bf_sptr self) -> long"""
        return _fec_swig.ber_bf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ber_bf_sptr self) -> basic_block_sptr"""
        return _fec_swig.ber_bf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ber_bf_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.ber_bf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ber_bf_sptr self, std::string name)"""
        return _fec_swig.ber_bf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ber_bf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.ber_bf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ber_bf_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.ber_bf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ber_bf_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.ber_bf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ber_bf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.ber_bf_sptr_message_subscribers(self, which_port)

# Register ber_bf_sptr in _fec_swig:
_fec_swig.ber_bf_sptr_swigregister(ber_bf_sptr)


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

class conv_bit_corr_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::conv_bit_corr_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__(conv_bit_corr_bb_sptr self) -> conv_bit_corr_bb_sptr
        __init__(conv_bit_corr_bb_sptr self, conv_bit_corr_bb p) -> conv_bit_corr_bb_sptr
        """
        _fec_swig.conv_bit_corr_bb_sptr_swiginit(self, _fec_swig.new_conv_bit_corr_bb_sptr(*args))

    def __deref__(self) -> "gr::fec::conv_bit_corr_bb *":
        r"""__deref__(conv_bit_corr_bb_sptr self) -> conv_bit_corr_bb"""
        return _fec_swig.conv_bit_corr_bb_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_conv_bit_corr_bb_sptr

    def make(self, correlator: "std::vector< unsigned long long,std::allocator< unsigned long long > >", corr_sym: "int", corr_len: "int", cut: "int", flush: "int", thresh: "float") -> "gr::fec::conv_bit_corr_bb::sptr":
        r"""make(conv_bit_corr_bb_sptr self, std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_make(self, correlator, corr_sym, corr_len, cut, flush, thresh)

    def data_garble_rate(self, taps: "int", syn_density: "float") -> "float":
        r"""data_garble_rate(conv_bit_corr_bb_sptr self, int taps, float syn_density) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_data_garble_rate(self, taps, syn_density)

    def history(self) -> "unsigned int":
        r"""history(conv_bit_corr_bb_sptr self) -> unsigned int"""
        return _fec_swig.conv_bit_corr_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(conv_bit_corr_bb_sptr self, int which, int delay)
        declare_sample_delay(conv_bit_corr_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(conv_bit_corr_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.conv_bit_corr_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(conv_bit_corr_bb_sptr self, int multiple)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(conv_bit_corr_bb_sptr self) -> double"""
        return _fec_swig.conv_bit_corr_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(conv_bit_corr_bb_sptr self) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(conv_bit_corr_bb_sptr self) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(conv_bit_corr_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(conv_bit_corr_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(conv_bit_corr_bb_sptr self, std::string level)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(conv_bit_corr_bb_sptr self, int m)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(conv_bit_corr_bb_sptr self)"""
        return _fec_swig.conv_bit_corr_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(conv_bit_corr_bb_sptr self, int m)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(conv_bit_corr_bb_sptr self, int i) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(conv_bit_corr_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(conv_bit_corr_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(conv_bit_corr_bb_sptr self, int i) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(conv_bit_corr_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(conv_bit_corr_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(conv_bit_corr_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(conv_bit_corr_bb_sptr self)"""
        return _fec_swig.conv_bit_corr_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(conv_bit_corr_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.conv_bit_corr_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(conv_bit_corr_bb_sptr self, int priority) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(conv_bit_corr_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(conv_bit_corr_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(conv_bit_corr_bb_sptr self) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(conv_bit_corr_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(conv_bit_corr_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(conv_bit_corr_bb_sptr self, std::string name)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(conv_bit_corr_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.conv_bit_corr_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(conv_bit_corr_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(conv_bit_corr_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(conv_bit_corr_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_subscribers(self, which_port)

# Register conv_bit_corr_bb_sptr in _fec_swig:
_fec_swig.conv_bit_corr_bb_sptr_swigregister(conv_bit_corr_bb_sptr)


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

class puncture_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::puncture_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__(puncture_bb_sptr self) -> puncture_bb_sptr
        __init__(puncture_bb_sptr self, puncture_bb p) -> puncture_bb_sptr
        """
        _fec_swig.puncture_bb_sptr_swiginit(self, _fec_swig.new_puncture_bb_sptr(*args))

    def __deref__(self) -> "gr::fec::puncture_bb *":
        r"""__deref__(puncture_bb_sptr self) -> puncture_bb"""
        return _fec_swig.puncture_bb_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_puncture_bb_sptr

    def make(self, puncsize: "int", puncpat: "int", delay: "int"=0) -> "gr::fec::puncture_bb::sptr":
        r"""make(puncture_bb_sptr self, int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
        return _fec_swig.puncture_bb_sptr_make(self, puncsize, puncpat, delay)

    def history(self) -> "unsigned int":
        r"""history(puncture_bb_sptr self) -> unsigned int"""
        return _fec_swig.puncture_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(puncture_bb_sptr self, int which, int delay)
        declare_sample_delay(puncture_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.puncture_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(puncture_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.puncture_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(puncture_bb_sptr self, int multiple)"""
        return _fec_swig.puncture_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(puncture_bb_sptr self) -> double"""
        return _fec_swig.puncture_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(puncture_bb_sptr self) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(puncture_bb_sptr self) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(puncture_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(puncture_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(puncture_bb_sptr self, std::string level)"""
        return _fec_swig.puncture_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(puncture_bb_sptr self, int m)"""
        return _fec_swig.puncture_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(puncture_bb_sptr self)"""
        return _fec_swig.puncture_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(puncture_bb_sptr self, int m)"""
        return _fec_swig.puncture_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(puncture_bb_sptr self, int i) -> long"""
        return _fec_swig.puncture_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(puncture_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(puncture_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.puncture_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(puncture_bb_sptr self, int i) -> long"""
        return _fec_swig.puncture_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(puncture_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(puncture_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.puncture_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(puncture_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.puncture_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(puncture_bb_sptr self)"""
        return _fec_swig.puncture_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(puncture_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.puncture_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(puncture_bb_sptr self, int priority) -> int"""
        return _fec_swig.puncture_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(puncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(puncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(puncture_bb_sptr self) -> long"""
        return _fec_swig.puncture_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(puncture_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.puncture_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(puncture_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.puncture_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(puncture_bb_sptr self, std::string name)"""
        return _fec_swig.puncture_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(puncture_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.puncture_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(puncture_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.puncture_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(puncture_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.puncture_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(puncture_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.puncture_bb_sptr_message_subscribers(self, which_port)

# Register puncture_bb_sptr in _fec_swig:
_fec_swig.puncture_bb_sptr_swigregister(puncture_bb_sptr)


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

class puncture_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::puncture_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__(puncture_ff_sptr self) -> puncture_ff_sptr
        __init__(puncture_ff_sptr self, puncture_ff p) -> puncture_ff_sptr
        """
        _fec_swig.puncture_ff_sptr_swiginit(self, _fec_swig.new_puncture_ff_sptr(*args))

    def __deref__(self) -> "gr::fec::puncture_ff *":
        r"""__deref__(puncture_ff_sptr self) -> puncture_ff"""
        return _fec_swig.puncture_ff_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_puncture_ff_sptr

    def make(self, puncsize: "int", puncpat: "int", delay: "int") -> "gr::fec::puncture_ff::sptr":
        r"""make(puncture_ff_sptr self, int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
        return _fec_swig.puncture_ff_sptr_make(self, puncsize, puncpat, delay)

    def history(self) -> "unsigned int":
        r"""history(puncture_ff_sptr self) -> unsigned int"""
        return _fec_swig.puncture_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(puncture_ff_sptr self, int which, int delay)
        declare_sample_delay(puncture_ff_sptr self, unsigned int delay)
        """
        return _fec_swig.puncture_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(puncture_ff_sptr self, int which) -> unsigned int"""
        return _fec_swig.puncture_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(puncture_ff_sptr self, int multiple)"""
        return _fec_swig.puncture_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(puncture_ff_sptr self) -> double"""
        return _fec_swig.puncture_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(puncture_ff_sptr self) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(puncture_ff_sptr self) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(puncture_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(puncture_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(puncture_ff_sptr self, std::string level)"""
        return _fec_swig.puncture_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(puncture_ff_sptr self, int m)"""
        return _fec_swig.puncture_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(puncture_ff_sptr self)"""
        return _fec_swig.puncture_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(puncture_ff_sptr self, int m)"""
        return _fec_swig.puncture_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(puncture_ff_sptr self, int i) -> long"""
        return _fec_swig.puncture_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(puncture_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(puncture_ff_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.puncture_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(puncture_ff_sptr self, int i) -> long"""
        return _fec_swig.puncture_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(puncture_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(puncture_ff_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.puncture_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(puncture_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.puncture_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(puncture_ff_sptr self)"""
        return _fec_swig.puncture_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(puncture_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.puncture_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(puncture_ff_sptr self, int priority) -> int"""
        return _fec_swig.puncture_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(puncture_ff_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(puncture_ff_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(puncture_ff_sptr self) -> long"""
        return _fec_swig.puncture_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(puncture_ff_sptr self) -> basic_block_sptr"""
        return _fec_swig.puncture_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(puncture_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.puncture_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(puncture_ff_sptr self, std::string name)"""
        return _fec_swig.puncture_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(puncture_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.puncture_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(puncture_ff_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.puncture_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(puncture_ff_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.puncture_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(puncture_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.puncture_ff_sptr_message_subscribers(self, which_port)

# Register puncture_ff_sptr in _fec_swig:
_fec_swig.puncture_ff_sptr_swigregister(puncture_ff_sptr)


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

class depuncture_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::fec::depuncture_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__(depuncture_bb_sptr self) -> depuncture_bb_sptr
        __init__(depuncture_bb_sptr self, depuncture_bb p) -> depuncture_bb_sptr
        """
        _fec_swig.depuncture_bb_sptr_swiginit(self, _fec_swig.new_depuncture_bb_sptr(*args))

    def __deref__(self) -> "gr::fec::depuncture_bb *":
        r"""__deref__(depuncture_bb_sptr self) -> depuncture_bb"""
        return _fec_swig.depuncture_bb_sptr___deref__(self)
    __swig_destroy__ = _fec_swig.delete_depuncture_bb_sptr

    def make(self, puncsize: "int", puncpat: "int", delay: "int"=0, symbol: "char"=127) -> "gr::fec::depuncture_bb::sptr":
        r"""make(depuncture_bb_sptr self, int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
        return _fec_swig.depuncture_bb_sptr_make(self, puncsize, puncpat, delay, symbol)

    def history(self) -> "unsigned int":
        r"""history(depuncture_bb_sptr self) -> unsigned int"""
        return _fec_swig.depuncture_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(depuncture_bb_sptr self, int which, int delay)
        declare_sample_delay(depuncture_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.depuncture_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(depuncture_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.depuncture_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(depuncture_bb_sptr self, int multiple)"""
        return _fec_swig.depuncture_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(depuncture_bb_sptr self) -> double"""
        return _fec_swig.depuncture_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(depuncture_bb_sptr self) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(depuncture_bb_sptr self) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(depuncture_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(depuncture_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(depuncture_bb_sptr self, std::string level)"""
        return _fec_swig.depuncture_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(depuncture_bb_sptr self, int m)"""
        return _fec_swig.depuncture_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(depuncture_bb_sptr self)"""
        return _fec_swig.depuncture_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(depuncture_bb_sptr self, int m)"""
        return _fec_swig.depuncture_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(depuncture_bb_sptr self, int i) -> long"""
        return _fec_swig.depuncture_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(depuncture_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(depuncture_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.depuncture_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(depuncture_bb_sptr self, int i) -> long"""
        return _fec_swig.depuncture_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(depuncture_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(depuncture_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.depuncture_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(depuncture_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.depuncture_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(depuncture_bb_sptr self)"""
        return _fec_swig.depuncture_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(depuncture_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.depuncture_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(depuncture_bb_sptr self, int priority) -> int"""
        return _fec_swig.depuncture_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(depuncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.depuncture_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(depuncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.depuncture_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(depuncture_bb_sptr self) -> long"""
        return _fec_swig.depuncture_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(depuncture_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.depuncture_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(depuncture_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.depuncture_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(depuncture_bb_sptr self, std::string name)"""
        return _fec_swig.depuncture_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(depuncture_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _fec_swig.depuncture_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(depuncture_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(depuncture_bb_sptr self) -> swig_pmt_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(depuncture_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_subscribers(self, which_port)

# Register depuncture_bb_sptr in _fec_swig:
_fec_swig.depuncture_bb_sptr_swigregister(depuncture_bb_sptr)


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



