# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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 _satellites_swig
else:
    import _satellites_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 _satellites_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 _satellites_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 _satellites_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 _satellites_swig.high_res_timer_epoch()
class ax100_decode(object):
    r"""Proxy of C++ gr::satellites::ax100_decode 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(verbose: "bool") -> "gr::satellites::ax100_decode::sptr":
        r"""make(bool verbose) -> ax100_decode_sptr"""
        return _satellites_swig.ax100_decode_make(verbose)
    __swig_destroy__ = _satellites_swig.delete_ax100_decode

# Register ax100_decode in _satellites_swig:
_satellites_swig.ax100_decode_swigregister(ax100_decode)

def ax100_decode_make(verbose: "bool") -> "gr::satellites::ax100_decode::sptr":
    r"""ax100_decode_make(bool verbose) -> ax100_decode_sptr"""
    return _satellites_swig.ax100_decode_make(verbose)

class ax100_decode_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::ax100_decode > 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__(ax100_decode_sptr self) -> ax100_decode_sptr
        __init__(ax100_decode_sptr self, ax100_decode p) -> ax100_decode_sptr
        """
        _satellites_swig.ax100_decode_sptr_swiginit(self, _satellites_swig.new_ax100_decode_sptr(*args))

    def __deref__(self) -> "gr::satellites::ax100_decode *":
        r"""__deref__(ax100_decode_sptr self) -> ax100_decode"""
        return _satellites_swig.ax100_decode_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_ax100_decode_sptr

    def make(self, verbose: "bool") -> "gr::satellites::ax100_decode::sptr":
        r"""make(ax100_decode_sptr self, bool verbose) -> ax100_decode_sptr"""
        return _satellites_swig.ax100_decode_sptr_make(self, verbose)

    def history(self) -> "unsigned int":
        r"""history(ax100_decode_sptr self) -> unsigned int"""
        return _satellites_swig.ax100_decode_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ax100_decode_sptr self, int which, int delay)
        declare_sample_delay(ax100_decode_sptr self, unsigned int delay)
        """
        return _satellites_swig.ax100_decode_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ax100_decode_sptr self, int which) -> unsigned int"""
        return _satellites_swig.ax100_decode_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ax100_decode_sptr self, int multiple)"""
        return _satellites_swig.ax100_decode_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ax100_decode_sptr self) -> int"""
        return _satellites_swig.ax100_decode_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ax100_decode_sptr self) -> double"""
        return _satellites_swig.ax100_decode_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ax100_decode_sptr self) -> uint64_t"""
        return _satellites_swig.ax100_decode_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ax100_decode_sptr self) -> uint64_t"""
        return _satellites_swig.ax100_decode_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ax100_decode_sptr self) -> bool"""
        return _satellites_swig.ax100_decode_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ax100_decode_sptr self) -> bool"""
        return _satellites_swig.ax100_decode_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ax100_decode_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.ax100_decode_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ax100_decode_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.ax100_decode_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ax100_decode_sptr self, std::string level)"""
        return _satellites_swig.ax100_decode_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ax100_decode_sptr self) -> std::string"""
        return _satellites_swig.ax100_decode_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ax100_decode_sptr self) -> int"""
        return _satellites_swig.ax100_decode_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ax100_decode_sptr self, int m)"""
        return _satellites_swig.ax100_decode_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ax100_decode_sptr self)"""
        return _satellites_swig.ax100_decode_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ax100_decode_sptr self) -> bool"""
        return _satellites_swig.ax100_decode_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ax100_decode_sptr self, int m)"""
        return _satellites_swig.ax100_decode_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ax100_decode_sptr self) -> int"""
        return _satellites_swig.ax100_decode_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ax100_decode_sptr self, int i) -> long"""
        return _satellites_swig.ax100_decode_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ax100_decode_sptr self, long max_output_buffer)
        set_max_output_buffer(ax100_decode_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.ax100_decode_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ax100_decode_sptr self, int i) -> long"""
        return _satellites_swig.ax100_decode_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ax100_decode_sptr self, long min_output_buffer)
        set_min_output_buffer(ax100_decode_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.ax100_decode_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ax100_decode_sptr self) -> float"""
        return _satellites_swig.ax100_decode_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ax100_decode_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.ax100_decode_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ax100_decode_sptr self)"""
        return _satellites_swig.ax100_decode_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ax100_decode_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.ax100_decode_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ax100_decode_sptr self) -> int"""
        return _satellites_swig.ax100_decode_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ax100_decode_sptr self) -> int"""
        return _satellites_swig.ax100_decode_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ax100_decode_sptr self, int priority) -> int"""
        return _satellites_swig.ax100_decode_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ax100_decode_sptr self) -> std::string"""
        return _satellites_swig.ax100_decode_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ax100_decode_sptr self) -> std::string"""
        return _satellites_swig.ax100_decode_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ax100_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.ax100_decode_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ax100_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.ax100_decode_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ax100_decode_sptr self) -> long"""
        return _satellites_swig.ax100_decode_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ax100_decode_sptr self) -> basic_block_sptr"""
        return _satellites_swig.ax100_decode_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ax100_decode_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.ax100_decode_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ax100_decode_sptr self) -> std::string"""
        return _satellites_swig.ax100_decode_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ax100_decode_sptr self, std::string name)"""
        return _satellites_swig.ax100_decode_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ax100_decode_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.ax100_decode_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ax100_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.ax100_decode_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ax100_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.ax100_decode_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ax100_decode_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.ax100_decode_sptr_message_subscribers(self, which_port)

# Register ax100_decode_sptr in _satellites_swig:
_satellites_swig.ax100_decode_sptr_swigregister(ax100_decode_sptr)


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

class convolutional_encoder(object):
    r"""Proxy of C++ gr::satellites::convolutional_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(constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::convolutional_encoder::sptr":
        r"""make(int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> convolutional_encoder_sptr"""
        return _satellites_swig.convolutional_encoder_make(constraint, polynomials)
    __swig_destroy__ = _satellites_swig.delete_convolutional_encoder

# Register convolutional_encoder in _satellites_swig:
_satellites_swig.convolutional_encoder_swigregister(convolutional_encoder)

def convolutional_encoder_make(constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::convolutional_encoder::sptr":
    r"""convolutional_encoder_make(int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> convolutional_encoder_sptr"""
    return _satellites_swig.convolutional_encoder_make(constraint, polynomials)

class convolutional_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::convolutional_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__(convolutional_encoder_sptr self) -> convolutional_encoder_sptr
        __init__(convolutional_encoder_sptr self, convolutional_encoder p) -> convolutional_encoder_sptr
        """
        _satellites_swig.convolutional_encoder_sptr_swiginit(self, _satellites_swig.new_convolutional_encoder_sptr(*args))

    def __deref__(self) -> "gr::satellites::convolutional_encoder *":
        r"""__deref__(convolutional_encoder_sptr self) -> convolutional_encoder"""
        return _satellites_swig.convolutional_encoder_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_convolutional_encoder_sptr

    def make(self, constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::convolutional_encoder::sptr":
        r"""make(convolutional_encoder_sptr self, int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> convolutional_encoder_sptr"""
        return _satellites_swig.convolutional_encoder_sptr_make(self, constraint, polynomials)

    def history(self) -> "unsigned int":
        r"""history(convolutional_encoder_sptr self) -> unsigned int"""
        return _satellites_swig.convolutional_encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(convolutional_encoder_sptr self, int which, int delay)
        declare_sample_delay(convolutional_encoder_sptr self, unsigned int delay)
        """
        return _satellites_swig.convolutional_encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(convolutional_encoder_sptr self, int which) -> unsigned int"""
        return _satellites_swig.convolutional_encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(convolutional_encoder_sptr self, int multiple)"""
        return _satellites_swig.convolutional_encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(convolutional_encoder_sptr self) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(convolutional_encoder_sptr self) -> double"""
        return _satellites_swig.convolutional_encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(convolutional_encoder_sptr self) -> uint64_t"""
        return _satellites_swig.convolutional_encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(convolutional_encoder_sptr self) -> uint64_t"""
        return _satellites_swig.convolutional_encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(convolutional_encoder_sptr self) -> bool"""
        return _satellites_swig.convolutional_encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(convolutional_encoder_sptr self) -> bool"""
        return _satellites_swig.convolutional_encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(convolutional_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.convolutional_encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(convolutional_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.convolutional_encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(convolutional_encoder_sptr self, std::string level)"""
        return _satellites_swig.convolutional_encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(convolutional_encoder_sptr self) -> std::string"""
        return _satellites_swig.convolutional_encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(convolutional_encoder_sptr self) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(convolutional_encoder_sptr self, int m)"""
        return _satellites_swig.convolutional_encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(convolutional_encoder_sptr self)"""
        return _satellites_swig.convolutional_encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(convolutional_encoder_sptr self) -> bool"""
        return _satellites_swig.convolutional_encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(convolutional_encoder_sptr self, int m)"""
        return _satellites_swig.convolutional_encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(convolutional_encoder_sptr self) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(convolutional_encoder_sptr self, int i) -> long"""
        return _satellites_swig.convolutional_encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(convolutional_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(convolutional_encoder_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.convolutional_encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(convolutional_encoder_sptr self, int i) -> long"""
        return _satellites_swig.convolutional_encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(convolutional_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(convolutional_encoder_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.convolutional_encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(convolutional_encoder_sptr self) -> float"""
        return _satellites_swig.convolutional_encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(convolutional_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.convolutional_encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(convolutional_encoder_sptr self)"""
        return _satellites_swig.convolutional_encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(convolutional_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.convolutional_encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(convolutional_encoder_sptr self) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(convolutional_encoder_sptr self) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(convolutional_encoder_sptr self, int priority) -> int"""
        return _satellites_swig.convolutional_encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(convolutional_encoder_sptr self) -> std::string"""
        return _satellites_swig.convolutional_encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(convolutional_encoder_sptr self) -> std::string"""
        return _satellites_swig.convolutional_encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(convolutional_encoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.convolutional_encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(convolutional_encoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.convolutional_encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(convolutional_encoder_sptr self) -> long"""
        return _satellites_swig.convolutional_encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(convolutional_encoder_sptr self) -> basic_block_sptr"""
        return _satellites_swig.convolutional_encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(convolutional_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.convolutional_encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(convolutional_encoder_sptr self) -> std::string"""
        return _satellites_swig.convolutional_encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(convolutional_encoder_sptr self, std::string name)"""
        return _satellites_swig.convolutional_encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(convolutional_encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.convolutional_encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(convolutional_encoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.convolutional_encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(convolutional_encoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.convolutional_encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(convolutional_encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.convolutional_encoder_sptr_message_subscribers(self, which_port)

# Register convolutional_encoder_sptr in _satellites_swig:
_satellites_swig.convolutional_encoder_sptr_swigregister(convolutional_encoder_sptr)


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

class decode_ra_code(object):
    r"""Proxy of C++ gr::satellites::decode_ra_code 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(size: "int") -> "gr::satellites::decode_ra_code::sptr":
        r"""make(int size) -> decode_ra_code_sptr"""
        return _satellites_swig.decode_ra_code_make(size)
    __swig_destroy__ = _satellites_swig.delete_decode_ra_code

# Register decode_ra_code in _satellites_swig:
_satellites_swig.decode_ra_code_swigregister(decode_ra_code)

def decode_ra_code_make(size: "int") -> "gr::satellites::decode_ra_code::sptr":
    r"""decode_ra_code_make(int size) -> decode_ra_code_sptr"""
    return _satellites_swig.decode_ra_code_make(size)

class decode_ra_code_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::decode_ra_code > 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_ra_code_sptr self) -> decode_ra_code_sptr
        __init__(decode_ra_code_sptr self, decode_ra_code p) -> decode_ra_code_sptr
        """
        _satellites_swig.decode_ra_code_sptr_swiginit(self, _satellites_swig.new_decode_ra_code_sptr(*args))

    def __deref__(self) -> "gr::satellites::decode_ra_code *":
        r"""__deref__(decode_ra_code_sptr self) -> decode_ra_code"""
        return _satellites_swig.decode_ra_code_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_decode_ra_code_sptr

    def make(self, size: "int") -> "gr::satellites::decode_ra_code::sptr":
        r"""make(decode_ra_code_sptr self, int size) -> decode_ra_code_sptr"""
        return _satellites_swig.decode_ra_code_sptr_make(self, size)

    def history(self) -> "unsigned int":
        r"""history(decode_ra_code_sptr self) -> unsigned int"""
        return _satellites_swig.decode_ra_code_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(decode_ra_code_sptr self, int which, int delay)
        declare_sample_delay(decode_ra_code_sptr self, unsigned int delay)
        """
        return _satellites_swig.decode_ra_code_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(decode_ra_code_sptr self, int which) -> unsigned int"""
        return _satellites_swig.decode_ra_code_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(decode_ra_code_sptr self, int multiple)"""
        return _satellites_swig.decode_ra_code_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(decode_ra_code_sptr self) -> int"""
        return _satellites_swig.decode_ra_code_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(decode_ra_code_sptr self) -> double"""
        return _satellites_swig.decode_ra_code_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(decode_ra_code_sptr self) -> uint64_t"""
        return _satellites_swig.decode_ra_code_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(decode_ra_code_sptr self) -> uint64_t"""
        return _satellites_swig.decode_ra_code_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(decode_ra_code_sptr self) -> bool"""
        return _satellites_swig.decode_ra_code_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(decode_ra_code_sptr self) -> bool"""
        return _satellites_swig.decode_ra_code_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(decode_ra_code_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.decode_ra_code_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(decode_ra_code_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.decode_ra_code_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(decode_ra_code_sptr self, std::string level)"""
        return _satellites_swig.decode_ra_code_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(decode_ra_code_sptr self) -> std::string"""
        return _satellites_swig.decode_ra_code_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(decode_ra_code_sptr self) -> int"""
        return _satellites_swig.decode_ra_code_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(decode_ra_code_sptr self, int m)"""
        return _satellites_swig.decode_ra_code_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(decode_ra_code_sptr self)"""
        return _satellites_swig.decode_ra_code_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(decode_ra_code_sptr self) -> bool"""
        return _satellites_swig.decode_ra_code_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(decode_ra_code_sptr self, int m)"""
        return _satellites_swig.decode_ra_code_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(decode_ra_code_sptr self) -> int"""
        return _satellites_swig.decode_ra_code_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(decode_ra_code_sptr self, int i) -> long"""
        return _satellites_swig.decode_ra_code_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(decode_ra_code_sptr self, long max_output_buffer)
        set_max_output_buffer(decode_ra_code_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.decode_ra_code_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(decode_ra_code_sptr self, int i) -> long"""
        return _satellites_swig.decode_ra_code_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(decode_ra_code_sptr self, long min_output_buffer)
        set_min_output_buffer(decode_ra_code_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.decode_ra_code_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(decode_ra_code_sptr self, int which) -> float
        pc_input_buffers_full(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_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_ra_code_sptr self, int which) -> float
        pc_input_buffers_full_avg(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_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_ra_code_sptr self, int which) -> float
        pc_input_buffers_full_var(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_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_ra_code_sptr self, int which) -> float
        pc_output_buffers_full(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_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_ra_code_sptr self, int which) -> float
        pc_output_buffers_full_avg(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_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_ra_code_sptr self, int which) -> float
        pc_output_buffers_full_var(decode_ra_code_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_ra_code_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(decode_ra_code_sptr self) -> float"""
        return _satellites_swig.decode_ra_code_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(decode_ra_code_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.decode_ra_code_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(decode_ra_code_sptr self)"""
        return _satellites_swig.decode_ra_code_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(decode_ra_code_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.decode_ra_code_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(decode_ra_code_sptr self) -> int"""
        return _satellites_swig.decode_ra_code_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(decode_ra_code_sptr self) -> int"""
        return _satellites_swig.decode_ra_code_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(decode_ra_code_sptr self, int priority) -> int"""
        return _satellites_swig.decode_ra_code_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(decode_ra_code_sptr self) -> std::string"""
        return _satellites_swig.decode_ra_code_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(decode_ra_code_sptr self) -> std::string"""
        return _satellites_swig.decode_ra_code_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(decode_ra_code_sptr self) -> io_signature_sptr"""
        return _satellites_swig.decode_ra_code_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(decode_ra_code_sptr self) -> io_signature_sptr"""
        return _satellites_swig.decode_ra_code_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(decode_ra_code_sptr self) -> long"""
        return _satellites_swig.decode_ra_code_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(decode_ra_code_sptr self) -> basic_block_sptr"""
        return _satellites_swig.decode_ra_code_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(decode_ra_code_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.decode_ra_code_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(decode_ra_code_sptr self) -> std::string"""
        return _satellites_swig.decode_ra_code_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(decode_ra_code_sptr self, std::string name)"""
        return _satellites_swig.decode_ra_code_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(decode_ra_code_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.decode_ra_code_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(decode_ra_code_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.decode_ra_code_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(decode_ra_code_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.decode_ra_code_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(decode_ra_code_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.decode_ra_code_sptr_message_subscribers(self, which_port)

# Register decode_ra_code_sptr in _satellites_swig:
_satellites_swig.decode_ra_code_sptr_swigregister(decode_ra_code_sptr)


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

class decode_rs(object):
    r"""Proxy of C++ gr::satellites::decode_rs class."""

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

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

    @staticmethod
    def make(*args) -> "gr::satellites::decode_rs::sptr":
        r"""
        make(int dual_basis, int interleave) -> decode_rs_sptr
        make(int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave) -> decode_rs_sptr
        """
        return _satellites_swig.decode_rs_make(*args)
    __swig_destroy__ = _satellites_swig.delete_decode_rs

# Register decode_rs in _satellites_swig:
_satellites_swig.decode_rs_swigregister(decode_rs)

def decode_rs_make(*args) -> "gr::satellites::decode_rs::sptr":
    r"""
    decode_rs_make(int dual_basis, int interleave) -> decode_rs_sptr
    decode_rs_make(int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave) -> decode_rs_sptr
    """
    return _satellites_swig.decode_rs_make(*args)

class decode_rs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::decode_rs > 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_rs_sptr self) -> decode_rs_sptr
        __init__(decode_rs_sptr self, decode_rs p) -> decode_rs_sptr
        """
        _satellites_swig.decode_rs_sptr_swiginit(self, _satellites_swig.new_decode_rs_sptr(*args))

    def __deref__(self) -> "gr::satellites::decode_rs *":
        r"""__deref__(decode_rs_sptr self) -> decode_rs"""
        return _satellites_swig.decode_rs_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_decode_rs_sptr

    def make(self, *args) -> "gr::satellites::decode_rs::sptr":
        r"""
        make(decode_rs_sptr self, int dual_basis, int interleave) -> decode_rs_sptr
        make(decode_rs_sptr self, int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave) -> decode_rs_sptr
        """
        return _satellites_swig.decode_rs_sptr_make(self, *args)

    def history(self) -> "unsigned int":
        r"""history(decode_rs_sptr self) -> unsigned int"""
        return _satellites_swig.decode_rs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(decode_rs_sptr self, int which, int delay)
        declare_sample_delay(decode_rs_sptr self, unsigned int delay)
        """
        return _satellites_swig.decode_rs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(decode_rs_sptr self, int which) -> unsigned int"""
        return _satellites_swig.decode_rs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(decode_rs_sptr self, int multiple)"""
        return _satellites_swig.decode_rs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(decode_rs_sptr self) -> int"""
        return _satellites_swig.decode_rs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(decode_rs_sptr self) -> double"""
        return _satellites_swig.decode_rs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(decode_rs_sptr self) -> uint64_t"""
        return _satellites_swig.decode_rs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(decode_rs_sptr self) -> uint64_t"""
        return _satellites_swig.decode_rs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(decode_rs_sptr self) -> bool"""
        return _satellites_swig.decode_rs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(decode_rs_sptr self) -> bool"""
        return _satellites_swig.decode_rs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(decode_rs_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.decode_rs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(decode_rs_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.decode_rs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(decode_rs_sptr self, std::string level)"""
        return _satellites_swig.decode_rs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(decode_rs_sptr self) -> std::string"""
        return _satellites_swig.decode_rs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(decode_rs_sptr self) -> int"""
        return _satellites_swig.decode_rs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(decode_rs_sptr self, int m)"""
        return _satellites_swig.decode_rs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(decode_rs_sptr self)"""
        return _satellites_swig.decode_rs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(decode_rs_sptr self) -> bool"""
        return _satellites_swig.decode_rs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(decode_rs_sptr self, int m)"""
        return _satellites_swig.decode_rs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(decode_rs_sptr self) -> int"""
        return _satellites_swig.decode_rs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(decode_rs_sptr self, int i) -> long"""
        return _satellites_swig.decode_rs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(decode_rs_sptr self, long max_output_buffer)
        set_max_output_buffer(decode_rs_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.decode_rs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(decode_rs_sptr self, int i) -> long"""
        return _satellites_swig.decode_rs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(decode_rs_sptr self, long min_output_buffer)
        set_min_output_buffer(decode_rs_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.decode_rs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(decode_rs_sptr self, int which) -> float
        pc_input_buffers_full(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_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_rs_sptr self, int which) -> float
        pc_input_buffers_full_avg(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_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_rs_sptr self, int which) -> float
        pc_input_buffers_full_var(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full_avg(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full_var(decode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.decode_rs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(decode_rs_sptr self) -> float"""
        return _satellites_swig.decode_rs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(decode_rs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.decode_rs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(decode_rs_sptr self)"""
        return _satellites_swig.decode_rs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(decode_rs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.decode_rs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(decode_rs_sptr self) -> int"""
        return _satellites_swig.decode_rs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(decode_rs_sptr self) -> int"""
        return _satellites_swig.decode_rs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(decode_rs_sptr self, int priority) -> int"""
        return _satellites_swig.decode_rs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(decode_rs_sptr self) -> std::string"""
        return _satellites_swig.decode_rs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(decode_rs_sptr self) -> std::string"""
        return _satellites_swig.decode_rs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(decode_rs_sptr self) -> io_signature_sptr"""
        return _satellites_swig.decode_rs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(decode_rs_sptr self) -> io_signature_sptr"""
        return _satellites_swig.decode_rs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(decode_rs_sptr self) -> long"""
        return _satellites_swig.decode_rs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(decode_rs_sptr self) -> basic_block_sptr"""
        return _satellites_swig.decode_rs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(decode_rs_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.decode_rs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(decode_rs_sptr self) -> std::string"""
        return _satellites_swig.decode_rs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(decode_rs_sptr self, std::string name)"""
        return _satellites_swig.decode_rs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(decode_rs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.decode_rs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(decode_rs_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.decode_rs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(decode_rs_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.decode_rs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(decode_rs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.decode_rs_sptr_message_subscribers(self, which_port)

# Register decode_rs_sptr in _satellites_swig:
_satellites_swig.decode_rs_sptr_swigregister(decode_rs_sptr)


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

class descrambler308(object):
    r"""Proxy of C++ gr::satellites::descrambler308 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::satellites::descrambler308::sptr":
        r"""make() -> descrambler308_sptr"""
        return _satellites_swig.descrambler308_make()
    __swig_destroy__ = _satellites_swig.delete_descrambler308

# Register descrambler308 in _satellites_swig:
_satellites_swig.descrambler308_swigregister(descrambler308)

def descrambler308_make() -> "gr::satellites::descrambler308::sptr":
    r"""descrambler308_make() -> descrambler308_sptr"""
    return _satellites_swig.descrambler308_make()

class descrambler308_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::descrambler308 > 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__(descrambler308_sptr self) -> descrambler308_sptr
        __init__(descrambler308_sptr self, descrambler308 p) -> descrambler308_sptr
        """
        _satellites_swig.descrambler308_sptr_swiginit(self, _satellites_swig.new_descrambler308_sptr(*args))

    def __deref__(self) -> "gr::satellites::descrambler308 *":
        r"""__deref__(descrambler308_sptr self) -> descrambler308"""
        return _satellites_swig.descrambler308_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_descrambler308_sptr

    def make(self) -> "gr::satellites::descrambler308::sptr":
        r"""make(descrambler308_sptr self) -> descrambler308_sptr"""
        return _satellites_swig.descrambler308_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(descrambler308_sptr self) -> unsigned int"""
        return _satellites_swig.descrambler308_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(descrambler308_sptr self, int which, int delay)
        declare_sample_delay(descrambler308_sptr self, unsigned int delay)
        """
        return _satellites_swig.descrambler308_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(descrambler308_sptr self, int which) -> unsigned int"""
        return _satellites_swig.descrambler308_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(descrambler308_sptr self, int multiple)"""
        return _satellites_swig.descrambler308_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(descrambler308_sptr self) -> int"""
        return _satellites_swig.descrambler308_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(descrambler308_sptr self) -> double"""
        return _satellites_swig.descrambler308_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(descrambler308_sptr self) -> uint64_t"""
        return _satellites_swig.descrambler308_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(descrambler308_sptr self) -> uint64_t"""
        return _satellites_swig.descrambler308_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(descrambler308_sptr self) -> bool"""
        return _satellites_swig.descrambler308_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(descrambler308_sptr self) -> bool"""
        return _satellites_swig.descrambler308_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(descrambler308_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.descrambler308_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(descrambler308_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.descrambler308_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(descrambler308_sptr self, std::string level)"""
        return _satellites_swig.descrambler308_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(descrambler308_sptr self) -> std::string"""
        return _satellites_swig.descrambler308_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(descrambler308_sptr self) -> int"""
        return _satellites_swig.descrambler308_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(descrambler308_sptr self, int m)"""
        return _satellites_swig.descrambler308_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(descrambler308_sptr self)"""
        return _satellites_swig.descrambler308_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(descrambler308_sptr self) -> bool"""
        return _satellites_swig.descrambler308_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(descrambler308_sptr self, int m)"""
        return _satellites_swig.descrambler308_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(descrambler308_sptr self) -> int"""
        return _satellites_swig.descrambler308_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(descrambler308_sptr self, int i) -> long"""
        return _satellites_swig.descrambler308_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(descrambler308_sptr self, long max_output_buffer)
        set_max_output_buffer(descrambler308_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.descrambler308_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(descrambler308_sptr self, int i) -> long"""
        return _satellites_swig.descrambler308_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(descrambler308_sptr self, long min_output_buffer)
        set_min_output_buffer(descrambler308_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.descrambler308_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(descrambler308_sptr self) -> float"""
        return _satellites_swig.descrambler308_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(descrambler308_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.descrambler308_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(descrambler308_sptr self)"""
        return _satellites_swig.descrambler308_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(descrambler308_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.descrambler308_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(descrambler308_sptr self) -> int"""
        return _satellites_swig.descrambler308_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(descrambler308_sptr self) -> int"""
        return _satellites_swig.descrambler308_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(descrambler308_sptr self, int priority) -> int"""
        return _satellites_swig.descrambler308_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(descrambler308_sptr self) -> std::string"""
        return _satellites_swig.descrambler308_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(descrambler308_sptr self) -> std::string"""
        return _satellites_swig.descrambler308_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(descrambler308_sptr self) -> io_signature_sptr"""
        return _satellites_swig.descrambler308_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(descrambler308_sptr self) -> io_signature_sptr"""
        return _satellites_swig.descrambler308_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(descrambler308_sptr self) -> long"""
        return _satellites_swig.descrambler308_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(descrambler308_sptr self) -> basic_block_sptr"""
        return _satellites_swig.descrambler308_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(descrambler308_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.descrambler308_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(descrambler308_sptr self) -> std::string"""
        return _satellites_swig.descrambler308_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(descrambler308_sptr self, std::string name)"""
        return _satellites_swig.descrambler308_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(descrambler308_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.descrambler308_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(descrambler308_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.descrambler308_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(descrambler308_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.descrambler308_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(descrambler308_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.descrambler308_sptr_message_subscribers(self, which_port)

# Register descrambler308_sptr in _satellites_swig:
_satellites_swig.descrambler308_sptr_swigregister(descrambler308_sptr)


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

class distributed_syncframe_soft(object):
    r"""Proxy of C++ gr::satellites::distributed_syncframe_soft 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(threshold: "int", syncword: "std::string const &", step: "int") -> "gr::satellites::distributed_syncframe_soft::sptr":
        r"""make(int threshold, std::string const & syncword, int step) -> distributed_syncframe_soft_sptr"""
        return _satellites_swig.distributed_syncframe_soft_make(threshold, syncword, step)
    __swig_destroy__ = _satellites_swig.delete_distributed_syncframe_soft

# Register distributed_syncframe_soft in _satellites_swig:
_satellites_swig.distributed_syncframe_soft_swigregister(distributed_syncframe_soft)

def distributed_syncframe_soft_make(threshold: "int", syncword: "std::string const &", step: "int") -> "gr::satellites::distributed_syncframe_soft::sptr":
    r"""distributed_syncframe_soft_make(int threshold, std::string const & syncword, int step) -> distributed_syncframe_soft_sptr"""
    return _satellites_swig.distributed_syncframe_soft_make(threshold, syncword, step)

class distributed_syncframe_soft_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::distributed_syncframe_soft > 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__(distributed_syncframe_soft_sptr self) -> distributed_syncframe_soft_sptr
        __init__(distributed_syncframe_soft_sptr self, distributed_syncframe_soft p) -> distributed_syncframe_soft_sptr
        """
        _satellites_swig.distributed_syncframe_soft_sptr_swiginit(self, _satellites_swig.new_distributed_syncframe_soft_sptr(*args))

    def __deref__(self) -> "gr::satellites::distributed_syncframe_soft *":
        r"""__deref__(distributed_syncframe_soft_sptr self) -> distributed_syncframe_soft"""
        return _satellites_swig.distributed_syncframe_soft_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_distributed_syncframe_soft_sptr

    def make(self, threshold: "int", syncword: "std::string const &", step: "int") -> "gr::satellites::distributed_syncframe_soft::sptr":
        r"""make(distributed_syncframe_soft_sptr self, int threshold, std::string const & syncword, int step) -> distributed_syncframe_soft_sptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_make(self, threshold, syncword, step)

    def history(self) -> "unsigned int":
        r"""history(distributed_syncframe_soft_sptr self) -> unsigned int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(distributed_syncframe_soft_sptr self, int which, int delay)
        declare_sample_delay(distributed_syncframe_soft_sptr self, unsigned int delay)
        """
        return _satellites_swig.distributed_syncframe_soft_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(distributed_syncframe_soft_sptr self, int which) -> unsigned int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(distributed_syncframe_soft_sptr self, int multiple)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(distributed_syncframe_soft_sptr self) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(distributed_syncframe_soft_sptr self) -> double"""
        return _satellites_swig.distributed_syncframe_soft_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(distributed_syncframe_soft_sptr self) -> uint64_t"""
        return _satellites_swig.distributed_syncframe_soft_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(distributed_syncframe_soft_sptr self) -> uint64_t"""
        return _satellites_swig.distributed_syncframe_soft_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(distributed_syncframe_soft_sptr self) -> bool"""
        return _satellites_swig.distributed_syncframe_soft_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(distributed_syncframe_soft_sptr self) -> bool"""
        return _satellites_swig.distributed_syncframe_soft_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(distributed_syncframe_soft_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.distributed_syncframe_soft_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(distributed_syncframe_soft_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.distributed_syncframe_soft_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(distributed_syncframe_soft_sptr self, std::string level)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(distributed_syncframe_soft_sptr self) -> std::string"""
        return _satellites_swig.distributed_syncframe_soft_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(distributed_syncframe_soft_sptr self) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(distributed_syncframe_soft_sptr self, int m)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(distributed_syncframe_soft_sptr self)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(distributed_syncframe_soft_sptr self) -> bool"""
        return _satellites_swig.distributed_syncframe_soft_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(distributed_syncframe_soft_sptr self, int m)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(distributed_syncframe_soft_sptr self) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(distributed_syncframe_soft_sptr self, int i) -> long"""
        return _satellites_swig.distributed_syncframe_soft_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(distributed_syncframe_soft_sptr self, long max_output_buffer)
        set_max_output_buffer(distributed_syncframe_soft_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.distributed_syncframe_soft_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(distributed_syncframe_soft_sptr self, int i) -> long"""
        return _satellites_swig.distributed_syncframe_soft_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(distributed_syncframe_soft_sptr self, long min_output_buffer)
        set_min_output_buffer(distributed_syncframe_soft_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.distributed_syncframe_soft_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(distributed_syncframe_soft_sptr self) -> float"""
        return _satellites_swig.distributed_syncframe_soft_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(distributed_syncframe_soft_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(distributed_syncframe_soft_sptr self)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(distributed_syncframe_soft_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.distributed_syncframe_soft_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(distributed_syncframe_soft_sptr self) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(distributed_syncframe_soft_sptr self) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(distributed_syncframe_soft_sptr self, int priority) -> int"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(distributed_syncframe_soft_sptr self) -> std::string"""
        return _satellites_swig.distributed_syncframe_soft_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(distributed_syncframe_soft_sptr self) -> std::string"""
        return _satellites_swig.distributed_syncframe_soft_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(distributed_syncframe_soft_sptr self) -> io_signature_sptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(distributed_syncframe_soft_sptr self) -> io_signature_sptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(distributed_syncframe_soft_sptr self) -> long"""
        return _satellites_swig.distributed_syncframe_soft_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(distributed_syncframe_soft_sptr self) -> basic_block_sptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(distributed_syncframe_soft_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.distributed_syncframe_soft_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(distributed_syncframe_soft_sptr self) -> std::string"""
        return _satellites_swig.distributed_syncframe_soft_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(distributed_syncframe_soft_sptr self, std::string name)"""
        return _satellites_swig.distributed_syncframe_soft_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(distributed_syncframe_soft_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.distributed_syncframe_soft_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(distributed_syncframe_soft_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(distributed_syncframe_soft_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(distributed_syncframe_soft_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.distributed_syncframe_soft_sptr_message_subscribers(self, which_port)

# Register distributed_syncframe_soft_sptr in _satellites_swig:
_satellites_swig.distributed_syncframe_soft_sptr_swigregister(distributed_syncframe_soft_sptr)


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

class encode_rs(object):
    r"""Proxy of C++ gr::satellites::encode_rs class."""

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

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

    @staticmethod
    def make(*args) -> "gr::satellites::encode_rs::sptr":
        r"""
        make(bool dual_basis, int interleave=1) -> encode_rs_sptr
        make(int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave=1) -> encode_rs_sptr
        """
        return _satellites_swig.encode_rs_make(*args)
    __swig_destroy__ = _satellites_swig.delete_encode_rs

# Register encode_rs in _satellites_swig:
_satellites_swig.encode_rs_swigregister(encode_rs)

def encode_rs_make(*args) -> "gr::satellites::encode_rs::sptr":
    r"""
    encode_rs_make(bool dual_basis, int interleave=1) -> encode_rs_sptr
    encode_rs_make(int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave=1) -> encode_rs_sptr
    """
    return _satellites_swig.encode_rs_make(*args)

class encode_rs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::encode_rs > 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_rs_sptr self) -> encode_rs_sptr
        __init__(encode_rs_sptr self, encode_rs p) -> encode_rs_sptr
        """
        _satellites_swig.encode_rs_sptr_swiginit(self, _satellites_swig.new_encode_rs_sptr(*args))

    def __deref__(self) -> "gr::satellites::encode_rs *":
        r"""__deref__(encode_rs_sptr self) -> encode_rs"""
        return _satellites_swig.encode_rs_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_encode_rs_sptr

    def make(self, *args) -> "gr::satellites::encode_rs::sptr":
        r"""
        make(encode_rs_sptr self, bool dual_basis, int interleave=1) -> encode_rs_sptr
        make(encode_rs_sptr self, int symsize, int gfpoly, int fcr, int prim, int nroots, int interleave=1) -> encode_rs_sptr
        """
        return _satellites_swig.encode_rs_sptr_make(self, *args)

    def history(self) -> "unsigned int":
        r"""history(encode_rs_sptr self) -> unsigned int"""
        return _satellites_swig.encode_rs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(encode_rs_sptr self, int which, int delay)
        declare_sample_delay(encode_rs_sptr self, unsigned int delay)
        """
        return _satellites_swig.encode_rs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(encode_rs_sptr self, int which) -> unsigned int"""
        return _satellites_swig.encode_rs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(encode_rs_sptr self, int multiple)"""
        return _satellites_swig.encode_rs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(encode_rs_sptr self) -> int"""
        return _satellites_swig.encode_rs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(encode_rs_sptr self) -> double"""
        return _satellites_swig.encode_rs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(encode_rs_sptr self) -> uint64_t"""
        return _satellites_swig.encode_rs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(encode_rs_sptr self) -> uint64_t"""
        return _satellites_swig.encode_rs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(encode_rs_sptr self) -> bool"""
        return _satellites_swig.encode_rs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(encode_rs_sptr self) -> bool"""
        return _satellites_swig.encode_rs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(encode_rs_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.encode_rs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(encode_rs_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.encode_rs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(encode_rs_sptr self, std::string level)"""
        return _satellites_swig.encode_rs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(encode_rs_sptr self) -> std::string"""
        return _satellites_swig.encode_rs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(encode_rs_sptr self) -> int"""
        return _satellites_swig.encode_rs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(encode_rs_sptr self, int m)"""
        return _satellites_swig.encode_rs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(encode_rs_sptr self)"""
        return _satellites_swig.encode_rs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(encode_rs_sptr self) -> bool"""
        return _satellites_swig.encode_rs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(encode_rs_sptr self, int m)"""
        return _satellites_swig.encode_rs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(encode_rs_sptr self) -> int"""
        return _satellites_swig.encode_rs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(encode_rs_sptr self, int i) -> long"""
        return _satellites_swig.encode_rs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(encode_rs_sptr self, long max_output_buffer)
        set_max_output_buffer(encode_rs_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.encode_rs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(encode_rs_sptr self, int i) -> long"""
        return _satellites_swig.encode_rs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(encode_rs_sptr self, long min_output_buffer)
        set_min_output_buffer(encode_rs_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.encode_rs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(encode_rs_sptr self, int which) -> float
        pc_input_buffers_full(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_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_rs_sptr self, int which) -> float
        pc_input_buffers_full_avg(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_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_rs_sptr self, int which) -> float
        pc_input_buffers_full_var(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full_avg(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_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_rs_sptr self, int which) -> float
        pc_output_buffers_full_var(encode_rs_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.encode_rs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(encode_rs_sptr self) -> float"""
        return _satellites_swig.encode_rs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(encode_rs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.encode_rs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(encode_rs_sptr self)"""
        return _satellites_swig.encode_rs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(encode_rs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.encode_rs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(encode_rs_sptr self) -> int"""
        return _satellites_swig.encode_rs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(encode_rs_sptr self) -> int"""
        return _satellites_swig.encode_rs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(encode_rs_sptr self, int priority) -> int"""
        return _satellites_swig.encode_rs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(encode_rs_sptr self) -> std::string"""
        return _satellites_swig.encode_rs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(encode_rs_sptr self) -> std::string"""
        return _satellites_swig.encode_rs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(encode_rs_sptr self) -> io_signature_sptr"""
        return _satellites_swig.encode_rs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(encode_rs_sptr self) -> io_signature_sptr"""
        return _satellites_swig.encode_rs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(encode_rs_sptr self) -> long"""
        return _satellites_swig.encode_rs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(encode_rs_sptr self) -> basic_block_sptr"""
        return _satellites_swig.encode_rs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(encode_rs_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.encode_rs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(encode_rs_sptr self) -> std::string"""
        return _satellites_swig.encode_rs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(encode_rs_sptr self, std::string name)"""
        return _satellites_swig.encode_rs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(encode_rs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.encode_rs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(encode_rs_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.encode_rs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(encode_rs_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.encode_rs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(encode_rs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.encode_rs_sptr_message_subscribers(self, which_port)

# Register encode_rs_sptr in _satellites_swig:
_satellites_swig.encode_rs_sptr_swigregister(encode_rs_sptr)


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

class lilacsat1_demux(object):
    r"""Proxy of C++ gr::satellites::lilacsat1_demux 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(tag: "std::string") -> "gr::satellites::lilacsat1_demux::sptr":
        r"""make(std::string tag) -> lilacsat1_demux_sptr"""
        return _satellites_swig.lilacsat1_demux_make(tag)
    __swig_destroy__ = _satellites_swig.delete_lilacsat1_demux

# Register lilacsat1_demux in _satellites_swig:
_satellites_swig.lilacsat1_demux_swigregister(lilacsat1_demux)

def lilacsat1_demux_make(tag: "std::string") -> "gr::satellites::lilacsat1_demux::sptr":
    r"""lilacsat1_demux_make(std::string tag) -> lilacsat1_demux_sptr"""
    return _satellites_swig.lilacsat1_demux_make(tag)

class lilacsat1_demux_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::lilacsat1_demux > 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__(lilacsat1_demux_sptr self) -> lilacsat1_demux_sptr
        __init__(lilacsat1_demux_sptr self, lilacsat1_demux p) -> lilacsat1_demux_sptr
        """
        _satellites_swig.lilacsat1_demux_sptr_swiginit(self, _satellites_swig.new_lilacsat1_demux_sptr(*args))

    def __deref__(self) -> "gr::satellites::lilacsat1_demux *":
        r"""__deref__(lilacsat1_demux_sptr self) -> lilacsat1_demux"""
        return _satellites_swig.lilacsat1_demux_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_lilacsat1_demux_sptr

    def make(self, tag: "std::string") -> "gr::satellites::lilacsat1_demux::sptr":
        r"""make(lilacsat1_demux_sptr self, std::string tag) -> lilacsat1_demux_sptr"""
        return _satellites_swig.lilacsat1_demux_sptr_make(self, tag)

    def history(self) -> "unsigned int":
        r"""history(lilacsat1_demux_sptr self) -> unsigned int"""
        return _satellites_swig.lilacsat1_demux_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(lilacsat1_demux_sptr self, int which, int delay)
        declare_sample_delay(lilacsat1_demux_sptr self, unsigned int delay)
        """
        return _satellites_swig.lilacsat1_demux_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(lilacsat1_demux_sptr self, int which) -> unsigned int"""
        return _satellites_swig.lilacsat1_demux_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(lilacsat1_demux_sptr self, int multiple)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(lilacsat1_demux_sptr self) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(lilacsat1_demux_sptr self) -> double"""
        return _satellites_swig.lilacsat1_demux_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(lilacsat1_demux_sptr self) -> uint64_t"""
        return _satellites_swig.lilacsat1_demux_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(lilacsat1_demux_sptr self) -> uint64_t"""
        return _satellites_swig.lilacsat1_demux_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(lilacsat1_demux_sptr self) -> bool"""
        return _satellites_swig.lilacsat1_demux_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(lilacsat1_demux_sptr self) -> bool"""
        return _satellites_swig.lilacsat1_demux_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(lilacsat1_demux_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.lilacsat1_demux_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(lilacsat1_demux_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.lilacsat1_demux_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(lilacsat1_demux_sptr self, std::string level)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(lilacsat1_demux_sptr self) -> std::string"""
        return _satellites_swig.lilacsat1_demux_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(lilacsat1_demux_sptr self) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(lilacsat1_demux_sptr self, int m)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(lilacsat1_demux_sptr self)"""
        return _satellites_swig.lilacsat1_demux_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(lilacsat1_demux_sptr self) -> bool"""
        return _satellites_swig.lilacsat1_demux_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(lilacsat1_demux_sptr self, int m)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(lilacsat1_demux_sptr self) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(lilacsat1_demux_sptr self, int i) -> long"""
        return _satellites_swig.lilacsat1_demux_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(lilacsat1_demux_sptr self, long max_output_buffer)
        set_max_output_buffer(lilacsat1_demux_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.lilacsat1_demux_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(lilacsat1_demux_sptr self, int i) -> long"""
        return _satellites_swig.lilacsat1_demux_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(lilacsat1_demux_sptr self, long min_output_buffer)
        set_min_output_buffer(lilacsat1_demux_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.lilacsat1_demux_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(lilacsat1_demux_sptr self) -> float"""
        return _satellites_swig.lilacsat1_demux_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(lilacsat1_demux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(lilacsat1_demux_sptr self)"""
        return _satellites_swig.lilacsat1_demux_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(lilacsat1_demux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.lilacsat1_demux_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(lilacsat1_demux_sptr self) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(lilacsat1_demux_sptr self) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(lilacsat1_demux_sptr self, int priority) -> int"""
        return _satellites_swig.lilacsat1_demux_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(lilacsat1_demux_sptr self) -> std::string"""
        return _satellites_swig.lilacsat1_demux_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(lilacsat1_demux_sptr self) -> std::string"""
        return _satellites_swig.lilacsat1_demux_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(lilacsat1_demux_sptr self) -> io_signature_sptr"""
        return _satellites_swig.lilacsat1_demux_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(lilacsat1_demux_sptr self) -> io_signature_sptr"""
        return _satellites_swig.lilacsat1_demux_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(lilacsat1_demux_sptr self) -> long"""
        return _satellites_swig.lilacsat1_demux_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(lilacsat1_demux_sptr self) -> basic_block_sptr"""
        return _satellites_swig.lilacsat1_demux_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(lilacsat1_demux_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.lilacsat1_demux_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(lilacsat1_demux_sptr self) -> std::string"""
        return _satellites_swig.lilacsat1_demux_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(lilacsat1_demux_sptr self, std::string name)"""
        return _satellites_swig.lilacsat1_demux_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(lilacsat1_demux_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.lilacsat1_demux_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(lilacsat1_demux_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.lilacsat1_demux_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(lilacsat1_demux_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.lilacsat1_demux_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(lilacsat1_demux_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.lilacsat1_demux_sptr_message_subscribers(self, which_port)

# Register lilacsat1_demux_sptr in _satellites_swig:
_satellites_swig.lilacsat1_demux_sptr_swigregister(lilacsat1_demux_sptr)


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

class matrix_deinterleaver_soft(object):
    r"""Proxy of C++ gr::satellites::matrix_deinterleaver_soft 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(rows: "int", cols: "int", output_size: "int", output_skip: "int") -> "gr::satellites::matrix_deinterleaver_soft::sptr":
        r"""make(int rows, int cols, int output_size, int output_skip) -> matrix_deinterleaver_soft_sptr"""
        return _satellites_swig.matrix_deinterleaver_soft_make(rows, cols, output_size, output_skip)
    __swig_destroy__ = _satellites_swig.delete_matrix_deinterleaver_soft

# Register matrix_deinterleaver_soft in _satellites_swig:
_satellites_swig.matrix_deinterleaver_soft_swigregister(matrix_deinterleaver_soft)

def matrix_deinterleaver_soft_make(rows: "int", cols: "int", output_size: "int", output_skip: "int") -> "gr::satellites::matrix_deinterleaver_soft::sptr":
    r"""matrix_deinterleaver_soft_make(int rows, int cols, int output_size, int output_skip) -> matrix_deinterleaver_soft_sptr"""
    return _satellites_swig.matrix_deinterleaver_soft_make(rows, cols, output_size, output_skip)

class matrix_deinterleaver_soft_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::matrix_deinterleaver_soft > 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_deinterleaver_soft_sptr self) -> matrix_deinterleaver_soft_sptr
        __init__(matrix_deinterleaver_soft_sptr self, matrix_deinterleaver_soft p) -> matrix_deinterleaver_soft_sptr
        """
        _satellites_swig.matrix_deinterleaver_soft_sptr_swiginit(self, _satellites_swig.new_matrix_deinterleaver_soft_sptr(*args))

    def __deref__(self) -> "gr::satellites::matrix_deinterleaver_soft *":
        r"""__deref__(matrix_deinterleaver_soft_sptr self) -> matrix_deinterleaver_soft"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_matrix_deinterleaver_soft_sptr

    def make(self, rows: "int", cols: "int", output_size: "int", output_skip: "int") -> "gr::satellites::matrix_deinterleaver_soft::sptr":
        r"""make(matrix_deinterleaver_soft_sptr self, int rows, int cols, int output_size, int output_skip) -> matrix_deinterleaver_soft_sptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_make(self, rows, cols, output_size, output_skip)

    def history(self) -> "unsigned int":
        r"""history(matrix_deinterleaver_soft_sptr self) -> unsigned int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(matrix_deinterleaver_soft_sptr self, int which, int delay)
        declare_sample_delay(matrix_deinterleaver_soft_sptr self, unsigned int delay)
        """
        return _satellites_swig.matrix_deinterleaver_soft_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(matrix_deinterleaver_soft_sptr self, int which) -> unsigned int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(matrix_deinterleaver_soft_sptr self, int multiple)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(matrix_deinterleaver_soft_sptr self) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(matrix_deinterleaver_soft_sptr self) -> double"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(matrix_deinterleaver_soft_sptr self) -> uint64_t"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(matrix_deinterleaver_soft_sptr self) -> uint64_t"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(matrix_deinterleaver_soft_sptr self) -> bool"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(matrix_deinterleaver_soft_sptr self) -> bool"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(matrix_deinterleaver_soft_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(matrix_deinterleaver_soft_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(matrix_deinterleaver_soft_sptr self, std::string level)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(matrix_deinterleaver_soft_sptr self) -> std::string"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(matrix_deinterleaver_soft_sptr self) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(matrix_deinterleaver_soft_sptr self, int m)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(matrix_deinterleaver_soft_sptr self)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(matrix_deinterleaver_soft_sptr self) -> bool"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(matrix_deinterleaver_soft_sptr self, int m)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(matrix_deinterleaver_soft_sptr self) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(matrix_deinterleaver_soft_sptr self, int i) -> long"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(matrix_deinterleaver_soft_sptr self, long max_output_buffer)
        set_max_output_buffer(matrix_deinterleaver_soft_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(matrix_deinterleaver_soft_sptr self, int i) -> long"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(matrix_deinterleaver_soft_sptr self, long min_output_buffer)
        set_min_output_buffer(matrix_deinterleaver_soft_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(matrix_deinterleaver_soft_sptr self) -> float"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(matrix_deinterleaver_soft_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(matrix_deinterleaver_soft_sptr self)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(matrix_deinterleaver_soft_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(matrix_deinterleaver_soft_sptr self) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(matrix_deinterleaver_soft_sptr self) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(matrix_deinterleaver_soft_sptr self, int priority) -> int"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(matrix_deinterleaver_soft_sptr self) -> std::string"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(matrix_deinterleaver_soft_sptr self) -> std::string"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(matrix_deinterleaver_soft_sptr self) -> io_signature_sptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(matrix_deinterleaver_soft_sptr self) -> io_signature_sptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(matrix_deinterleaver_soft_sptr self) -> long"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(matrix_deinterleaver_soft_sptr self) -> basic_block_sptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(matrix_deinterleaver_soft_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(matrix_deinterleaver_soft_sptr self) -> std::string"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(matrix_deinterleaver_soft_sptr self, std::string name)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(matrix_deinterleaver_soft_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(matrix_deinterleaver_soft_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(matrix_deinterleaver_soft_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(matrix_deinterleaver_soft_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.matrix_deinterleaver_soft_sptr_message_subscribers(self, which_port)

# Register matrix_deinterleaver_soft_sptr in _satellites_swig:
_satellites_swig.matrix_deinterleaver_soft_sptr_swigregister(matrix_deinterleaver_soft_sptr)


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

class nrzi_decode(object):
    r"""Proxy of C++ gr::satellites::nrzi_decode 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::satellites::nrzi_decode::sptr":
        r"""make() -> nrzi_decode_sptr"""
        return _satellites_swig.nrzi_decode_make()
    __swig_destroy__ = _satellites_swig.delete_nrzi_decode

# Register nrzi_decode in _satellites_swig:
_satellites_swig.nrzi_decode_swigregister(nrzi_decode)

def nrzi_decode_make() -> "gr::satellites::nrzi_decode::sptr":
    r"""nrzi_decode_make() -> nrzi_decode_sptr"""
    return _satellites_swig.nrzi_decode_make()

class nrzi_decode_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::nrzi_decode > 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__(nrzi_decode_sptr self) -> nrzi_decode_sptr
        __init__(nrzi_decode_sptr self, nrzi_decode p) -> nrzi_decode_sptr
        """
        _satellites_swig.nrzi_decode_sptr_swiginit(self, _satellites_swig.new_nrzi_decode_sptr(*args))

    def __deref__(self) -> "gr::satellites::nrzi_decode *":
        r"""__deref__(nrzi_decode_sptr self) -> nrzi_decode"""
        return _satellites_swig.nrzi_decode_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_nrzi_decode_sptr

    def make(self) -> "gr::satellites::nrzi_decode::sptr":
        r"""make(nrzi_decode_sptr self) -> nrzi_decode_sptr"""
        return _satellites_swig.nrzi_decode_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(nrzi_decode_sptr self) -> unsigned int"""
        return _satellites_swig.nrzi_decode_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(nrzi_decode_sptr self, int which, int delay)
        declare_sample_delay(nrzi_decode_sptr self, unsigned int delay)
        """
        return _satellites_swig.nrzi_decode_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(nrzi_decode_sptr self, int which) -> unsigned int"""
        return _satellites_swig.nrzi_decode_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(nrzi_decode_sptr self, int multiple)"""
        return _satellites_swig.nrzi_decode_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(nrzi_decode_sptr self) -> int"""
        return _satellites_swig.nrzi_decode_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(nrzi_decode_sptr self) -> double"""
        return _satellites_swig.nrzi_decode_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(nrzi_decode_sptr self) -> uint64_t"""
        return _satellites_swig.nrzi_decode_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(nrzi_decode_sptr self) -> uint64_t"""
        return _satellites_swig.nrzi_decode_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(nrzi_decode_sptr self) -> bool"""
        return _satellites_swig.nrzi_decode_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(nrzi_decode_sptr self) -> bool"""
        return _satellites_swig.nrzi_decode_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(nrzi_decode_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.nrzi_decode_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(nrzi_decode_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.nrzi_decode_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(nrzi_decode_sptr self, std::string level)"""
        return _satellites_swig.nrzi_decode_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(nrzi_decode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_decode_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(nrzi_decode_sptr self) -> int"""
        return _satellites_swig.nrzi_decode_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(nrzi_decode_sptr self, int m)"""
        return _satellites_swig.nrzi_decode_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(nrzi_decode_sptr self)"""
        return _satellites_swig.nrzi_decode_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(nrzi_decode_sptr self) -> bool"""
        return _satellites_swig.nrzi_decode_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(nrzi_decode_sptr self, int m)"""
        return _satellites_swig.nrzi_decode_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(nrzi_decode_sptr self) -> int"""
        return _satellites_swig.nrzi_decode_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(nrzi_decode_sptr self, int i) -> long"""
        return _satellites_swig.nrzi_decode_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(nrzi_decode_sptr self, long max_output_buffer)
        set_max_output_buffer(nrzi_decode_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.nrzi_decode_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(nrzi_decode_sptr self, int i) -> long"""
        return _satellites_swig.nrzi_decode_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(nrzi_decode_sptr self, long min_output_buffer)
        set_min_output_buffer(nrzi_decode_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.nrzi_decode_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(nrzi_decode_sptr self) -> float"""
        return _satellites_swig.nrzi_decode_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(nrzi_decode_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.nrzi_decode_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(nrzi_decode_sptr self)"""
        return _satellites_swig.nrzi_decode_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(nrzi_decode_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.nrzi_decode_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(nrzi_decode_sptr self) -> int"""
        return _satellites_swig.nrzi_decode_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(nrzi_decode_sptr self) -> int"""
        return _satellites_swig.nrzi_decode_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(nrzi_decode_sptr self, int priority) -> int"""
        return _satellites_swig.nrzi_decode_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(nrzi_decode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_decode_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(nrzi_decode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_decode_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(nrzi_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nrzi_decode_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(nrzi_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nrzi_decode_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(nrzi_decode_sptr self) -> long"""
        return _satellites_swig.nrzi_decode_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(nrzi_decode_sptr self) -> basic_block_sptr"""
        return _satellites_swig.nrzi_decode_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(nrzi_decode_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.nrzi_decode_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(nrzi_decode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_decode_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(nrzi_decode_sptr self, std::string name)"""
        return _satellites_swig.nrzi_decode_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(nrzi_decode_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.nrzi_decode_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(nrzi_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_decode_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(nrzi_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_decode_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(nrzi_decode_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_decode_sptr_message_subscribers(self, which_port)

# Register nrzi_decode_sptr in _satellites_swig:
_satellites_swig.nrzi_decode_sptr_swigregister(nrzi_decode_sptr)


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

class nrzi_encode(object):
    r"""Proxy of C++ gr::satellites::nrzi_encode 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::satellites::nrzi_encode::sptr":
        r"""make() -> nrzi_encode_sptr"""
        return _satellites_swig.nrzi_encode_make()
    __swig_destroy__ = _satellites_swig.delete_nrzi_encode

# Register nrzi_encode in _satellites_swig:
_satellites_swig.nrzi_encode_swigregister(nrzi_encode)

def nrzi_encode_make() -> "gr::satellites::nrzi_encode::sptr":
    r"""nrzi_encode_make() -> nrzi_encode_sptr"""
    return _satellites_swig.nrzi_encode_make()

class nrzi_encode_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::nrzi_encode > 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__(nrzi_encode_sptr self) -> nrzi_encode_sptr
        __init__(nrzi_encode_sptr self, nrzi_encode p) -> nrzi_encode_sptr
        """
        _satellites_swig.nrzi_encode_sptr_swiginit(self, _satellites_swig.new_nrzi_encode_sptr(*args))

    def __deref__(self) -> "gr::satellites::nrzi_encode *":
        r"""__deref__(nrzi_encode_sptr self) -> nrzi_encode"""
        return _satellites_swig.nrzi_encode_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_nrzi_encode_sptr

    def make(self) -> "gr::satellites::nrzi_encode::sptr":
        r"""make(nrzi_encode_sptr self) -> nrzi_encode_sptr"""
        return _satellites_swig.nrzi_encode_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(nrzi_encode_sptr self) -> unsigned int"""
        return _satellites_swig.nrzi_encode_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(nrzi_encode_sptr self, int which, int delay)
        declare_sample_delay(nrzi_encode_sptr self, unsigned int delay)
        """
        return _satellites_swig.nrzi_encode_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(nrzi_encode_sptr self, int which) -> unsigned int"""
        return _satellites_swig.nrzi_encode_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(nrzi_encode_sptr self, int multiple)"""
        return _satellites_swig.nrzi_encode_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(nrzi_encode_sptr self) -> int"""
        return _satellites_swig.nrzi_encode_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(nrzi_encode_sptr self) -> double"""
        return _satellites_swig.nrzi_encode_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(nrzi_encode_sptr self) -> uint64_t"""
        return _satellites_swig.nrzi_encode_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(nrzi_encode_sptr self) -> uint64_t"""
        return _satellites_swig.nrzi_encode_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(nrzi_encode_sptr self) -> bool"""
        return _satellites_swig.nrzi_encode_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(nrzi_encode_sptr self) -> bool"""
        return _satellites_swig.nrzi_encode_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(nrzi_encode_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.nrzi_encode_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(nrzi_encode_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.nrzi_encode_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(nrzi_encode_sptr self, std::string level)"""
        return _satellites_swig.nrzi_encode_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(nrzi_encode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_encode_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(nrzi_encode_sptr self) -> int"""
        return _satellites_swig.nrzi_encode_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(nrzi_encode_sptr self, int m)"""
        return _satellites_swig.nrzi_encode_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(nrzi_encode_sptr self)"""
        return _satellites_swig.nrzi_encode_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(nrzi_encode_sptr self) -> bool"""
        return _satellites_swig.nrzi_encode_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(nrzi_encode_sptr self, int m)"""
        return _satellites_swig.nrzi_encode_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(nrzi_encode_sptr self) -> int"""
        return _satellites_swig.nrzi_encode_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(nrzi_encode_sptr self, int i) -> long"""
        return _satellites_swig.nrzi_encode_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(nrzi_encode_sptr self, long max_output_buffer)
        set_max_output_buffer(nrzi_encode_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.nrzi_encode_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(nrzi_encode_sptr self, int i) -> long"""
        return _satellites_swig.nrzi_encode_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(nrzi_encode_sptr self, long min_output_buffer)
        set_min_output_buffer(nrzi_encode_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.nrzi_encode_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(nrzi_encode_sptr self) -> float"""
        return _satellites_swig.nrzi_encode_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(nrzi_encode_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.nrzi_encode_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(nrzi_encode_sptr self)"""
        return _satellites_swig.nrzi_encode_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(nrzi_encode_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.nrzi_encode_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(nrzi_encode_sptr self) -> int"""
        return _satellites_swig.nrzi_encode_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(nrzi_encode_sptr self) -> int"""
        return _satellites_swig.nrzi_encode_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(nrzi_encode_sptr self, int priority) -> int"""
        return _satellites_swig.nrzi_encode_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(nrzi_encode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_encode_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(nrzi_encode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_encode_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(nrzi_encode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nrzi_encode_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(nrzi_encode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nrzi_encode_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(nrzi_encode_sptr self) -> long"""
        return _satellites_swig.nrzi_encode_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(nrzi_encode_sptr self) -> basic_block_sptr"""
        return _satellites_swig.nrzi_encode_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(nrzi_encode_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.nrzi_encode_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(nrzi_encode_sptr self) -> std::string"""
        return _satellites_swig.nrzi_encode_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(nrzi_encode_sptr self, std::string name)"""
        return _satellites_swig.nrzi_encode_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(nrzi_encode_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.nrzi_encode_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(nrzi_encode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_encode_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(nrzi_encode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_encode_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(nrzi_encode_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.nrzi_encode_sptr_message_subscribers(self, which_port)

# Register nrzi_encode_sptr in _satellites_swig:
_satellites_swig.nrzi_encode_sptr_swigregister(nrzi_encode_sptr)


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

class nusat_decoder(object):
    r"""Proxy of C++ gr::satellites::nusat_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() -> "gr::satellites::nusat_decoder::sptr":
        r"""make() -> nusat_decoder_sptr"""
        return _satellites_swig.nusat_decoder_make()
    __swig_destroy__ = _satellites_swig.delete_nusat_decoder

# Register nusat_decoder in _satellites_swig:
_satellites_swig.nusat_decoder_swigregister(nusat_decoder)

def nusat_decoder_make() -> "gr::satellites::nusat_decoder::sptr":
    r"""nusat_decoder_make() -> nusat_decoder_sptr"""
    return _satellites_swig.nusat_decoder_make()

class nusat_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::nusat_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__(nusat_decoder_sptr self) -> nusat_decoder_sptr
        __init__(nusat_decoder_sptr self, nusat_decoder p) -> nusat_decoder_sptr
        """
        _satellites_swig.nusat_decoder_sptr_swiginit(self, _satellites_swig.new_nusat_decoder_sptr(*args))

    def __deref__(self) -> "gr::satellites::nusat_decoder *":
        r"""__deref__(nusat_decoder_sptr self) -> nusat_decoder"""
        return _satellites_swig.nusat_decoder_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_nusat_decoder_sptr

    def make(self) -> "gr::satellites::nusat_decoder::sptr":
        r"""make(nusat_decoder_sptr self) -> nusat_decoder_sptr"""
        return _satellites_swig.nusat_decoder_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(nusat_decoder_sptr self) -> unsigned int"""
        return _satellites_swig.nusat_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(nusat_decoder_sptr self, int which, int delay)
        declare_sample_delay(nusat_decoder_sptr self, unsigned int delay)
        """
        return _satellites_swig.nusat_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(nusat_decoder_sptr self, int which) -> unsigned int"""
        return _satellites_swig.nusat_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(nusat_decoder_sptr self, int multiple)"""
        return _satellites_swig.nusat_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(nusat_decoder_sptr self) -> int"""
        return _satellites_swig.nusat_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(nusat_decoder_sptr self) -> double"""
        return _satellites_swig.nusat_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(nusat_decoder_sptr self) -> uint64_t"""
        return _satellites_swig.nusat_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(nusat_decoder_sptr self) -> uint64_t"""
        return _satellites_swig.nusat_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(nusat_decoder_sptr self) -> bool"""
        return _satellites_swig.nusat_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(nusat_decoder_sptr self) -> bool"""
        return _satellites_swig.nusat_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(nusat_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.nusat_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(nusat_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.nusat_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(nusat_decoder_sptr self, std::string level)"""
        return _satellites_swig.nusat_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(nusat_decoder_sptr self) -> std::string"""
        return _satellites_swig.nusat_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(nusat_decoder_sptr self) -> int"""
        return _satellites_swig.nusat_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(nusat_decoder_sptr self, int m)"""
        return _satellites_swig.nusat_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(nusat_decoder_sptr self)"""
        return _satellites_swig.nusat_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(nusat_decoder_sptr self) -> bool"""
        return _satellites_swig.nusat_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(nusat_decoder_sptr self, int m)"""
        return _satellites_swig.nusat_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(nusat_decoder_sptr self) -> int"""
        return _satellites_swig.nusat_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(nusat_decoder_sptr self, int i) -> long"""
        return _satellites_swig.nusat_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(nusat_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(nusat_decoder_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.nusat_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(nusat_decoder_sptr self, int i) -> long"""
        return _satellites_swig.nusat_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(nusat_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(nusat_decoder_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.nusat_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(nusat_decoder_sptr self) -> float"""
        return _satellites_swig.nusat_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(nusat_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.nusat_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(nusat_decoder_sptr self)"""
        return _satellites_swig.nusat_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(nusat_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.nusat_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(nusat_decoder_sptr self) -> int"""
        return _satellites_swig.nusat_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(nusat_decoder_sptr self) -> int"""
        return _satellites_swig.nusat_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(nusat_decoder_sptr self, int priority) -> int"""
        return _satellites_swig.nusat_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(nusat_decoder_sptr self) -> std::string"""
        return _satellites_swig.nusat_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(nusat_decoder_sptr self) -> std::string"""
        return _satellites_swig.nusat_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(nusat_decoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nusat_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(nusat_decoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.nusat_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(nusat_decoder_sptr self) -> long"""
        return _satellites_swig.nusat_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(nusat_decoder_sptr self) -> basic_block_sptr"""
        return _satellites_swig.nusat_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(nusat_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.nusat_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(nusat_decoder_sptr self) -> std::string"""
        return _satellites_swig.nusat_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(nusat_decoder_sptr self, std::string name)"""
        return _satellites_swig.nusat_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(nusat_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.nusat_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(nusat_decoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nusat_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(nusat_decoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.nusat_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(nusat_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.nusat_decoder_sptr_message_subscribers(self, which_port)

# Register nusat_decoder_sptr in _satellites_swig:
_satellites_swig.nusat_decoder_sptr_swigregister(nusat_decoder_sptr)


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

class pdu_add_meta(object):
    r"""Proxy of C++ gr::satellites::pdu_add_meta 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(meta: "swig_pmt_ptr") -> "gr::satellites::pdu_add_meta::sptr":
        r"""make(swig_pmt_ptr meta) -> pdu_add_meta_sptr"""
        return _satellites_swig.pdu_add_meta_make(meta)
    __swig_destroy__ = _satellites_swig.delete_pdu_add_meta

# Register pdu_add_meta in _satellites_swig:
_satellites_swig.pdu_add_meta_swigregister(pdu_add_meta)

def pdu_add_meta_make(meta: "swig_pmt_ptr") -> "gr::satellites::pdu_add_meta::sptr":
    r"""pdu_add_meta_make(swig_pmt_ptr meta) -> pdu_add_meta_sptr"""
    return _satellites_swig.pdu_add_meta_make(meta)

class pdu_add_meta_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::pdu_add_meta > 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__(pdu_add_meta_sptr self) -> pdu_add_meta_sptr
        __init__(pdu_add_meta_sptr self, pdu_add_meta p) -> pdu_add_meta_sptr
        """
        _satellites_swig.pdu_add_meta_sptr_swiginit(self, _satellites_swig.new_pdu_add_meta_sptr(*args))

    def __deref__(self) -> "gr::satellites::pdu_add_meta *":
        r"""__deref__(pdu_add_meta_sptr self) -> pdu_add_meta"""
        return _satellites_swig.pdu_add_meta_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_pdu_add_meta_sptr

    def make(self, meta: "swig_pmt_ptr") -> "gr::satellites::pdu_add_meta::sptr":
        r"""make(pdu_add_meta_sptr self, swig_pmt_ptr meta) -> pdu_add_meta_sptr"""
        return _satellites_swig.pdu_add_meta_sptr_make(self, meta)

    def history(self) -> "unsigned int":
        r"""history(pdu_add_meta_sptr self) -> unsigned int"""
        return _satellites_swig.pdu_add_meta_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_add_meta_sptr self, int which, int delay)
        declare_sample_delay(pdu_add_meta_sptr self, unsigned int delay)
        """
        return _satellites_swig.pdu_add_meta_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_add_meta_sptr self, int which) -> unsigned int"""
        return _satellites_swig.pdu_add_meta_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_add_meta_sptr self, int multiple)"""
        return _satellites_swig.pdu_add_meta_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_add_meta_sptr self) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_add_meta_sptr self) -> double"""
        return _satellites_swig.pdu_add_meta_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_add_meta_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_add_meta_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_add_meta_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_add_meta_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_add_meta_sptr self) -> bool"""
        return _satellites_swig.pdu_add_meta_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_add_meta_sptr self) -> bool"""
        return _satellites_swig.pdu_add_meta_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_add_meta_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.pdu_add_meta_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_add_meta_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.pdu_add_meta_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_add_meta_sptr self, std::string level)"""
        return _satellites_swig.pdu_add_meta_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_add_meta_sptr self) -> std::string"""
        return _satellites_swig.pdu_add_meta_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_add_meta_sptr self) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_add_meta_sptr self, int m)"""
        return _satellites_swig.pdu_add_meta_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_add_meta_sptr self)"""
        return _satellites_swig.pdu_add_meta_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_add_meta_sptr self) -> bool"""
        return _satellites_swig.pdu_add_meta_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_add_meta_sptr self, int m)"""
        return _satellites_swig.pdu_add_meta_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_add_meta_sptr self) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_add_meta_sptr self, int i) -> long"""
        return _satellites_swig.pdu_add_meta_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_add_meta_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_add_meta_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.pdu_add_meta_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_add_meta_sptr self, int i) -> long"""
        return _satellites_swig.pdu_add_meta_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_add_meta_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_add_meta_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.pdu_add_meta_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_add_meta_sptr self) -> float"""
        return _satellites_swig.pdu_add_meta_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_add_meta_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.pdu_add_meta_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_add_meta_sptr self)"""
        return _satellites_swig.pdu_add_meta_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_add_meta_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.pdu_add_meta_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_add_meta_sptr self) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_add_meta_sptr self) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_add_meta_sptr self, int priority) -> int"""
        return _satellites_swig.pdu_add_meta_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_add_meta_sptr self) -> std::string"""
        return _satellites_swig.pdu_add_meta_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_add_meta_sptr self) -> std::string"""
        return _satellites_swig.pdu_add_meta_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_add_meta_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_add_meta_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_add_meta_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_add_meta_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_add_meta_sptr self) -> long"""
        return _satellites_swig.pdu_add_meta_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_add_meta_sptr self) -> basic_block_sptr"""
        return _satellites_swig.pdu_add_meta_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_add_meta_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.pdu_add_meta_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_add_meta_sptr self) -> std::string"""
        return _satellites_swig.pdu_add_meta_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_add_meta_sptr self, std::string name)"""
        return _satellites_swig.pdu_add_meta_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_add_meta_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.pdu_add_meta_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_add_meta_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_add_meta_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_add_meta_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_add_meta_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_add_meta_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_add_meta_sptr_message_subscribers(self, which_port)

# Register pdu_add_meta_sptr in _satellites_swig:
_satellites_swig.pdu_add_meta_sptr_swigregister(pdu_add_meta_sptr)


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

class pdu_head_tail(object):
    r"""Proxy of C++ gr::satellites::pdu_head_tail 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(mode: "int", num: "size_t") -> "gr::satellites::pdu_head_tail::sptr":
        r"""make(int mode, size_t num) -> pdu_head_tail_sptr"""
        return _satellites_swig.pdu_head_tail_make(mode, num)
    __swig_destroy__ = _satellites_swig.delete_pdu_head_tail

# Register pdu_head_tail in _satellites_swig:
_satellites_swig.pdu_head_tail_swigregister(pdu_head_tail)

def pdu_head_tail_make(mode: "int", num: "size_t") -> "gr::satellites::pdu_head_tail::sptr":
    r"""pdu_head_tail_make(int mode, size_t num) -> pdu_head_tail_sptr"""
    return _satellites_swig.pdu_head_tail_make(mode, num)

class pdu_head_tail_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::pdu_head_tail > 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__(pdu_head_tail_sptr self) -> pdu_head_tail_sptr
        __init__(pdu_head_tail_sptr self, pdu_head_tail p) -> pdu_head_tail_sptr
        """
        _satellites_swig.pdu_head_tail_sptr_swiginit(self, _satellites_swig.new_pdu_head_tail_sptr(*args))

    def __deref__(self) -> "gr::satellites::pdu_head_tail *":
        r"""__deref__(pdu_head_tail_sptr self) -> pdu_head_tail"""
        return _satellites_swig.pdu_head_tail_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_pdu_head_tail_sptr

    def make(self, mode: "int", num: "size_t") -> "gr::satellites::pdu_head_tail::sptr":
        r"""make(pdu_head_tail_sptr self, int mode, size_t num) -> pdu_head_tail_sptr"""
        return _satellites_swig.pdu_head_tail_sptr_make(self, mode, num)

    def history(self) -> "unsigned int":
        r"""history(pdu_head_tail_sptr self) -> unsigned int"""
        return _satellites_swig.pdu_head_tail_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_head_tail_sptr self, int which, int delay)
        declare_sample_delay(pdu_head_tail_sptr self, unsigned int delay)
        """
        return _satellites_swig.pdu_head_tail_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_head_tail_sptr self, int which) -> unsigned int"""
        return _satellites_swig.pdu_head_tail_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_head_tail_sptr self, int multiple)"""
        return _satellites_swig.pdu_head_tail_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_head_tail_sptr self) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_head_tail_sptr self) -> double"""
        return _satellites_swig.pdu_head_tail_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_head_tail_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_head_tail_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_head_tail_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_head_tail_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_head_tail_sptr self) -> bool"""
        return _satellites_swig.pdu_head_tail_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_head_tail_sptr self) -> bool"""
        return _satellites_swig.pdu_head_tail_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_head_tail_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.pdu_head_tail_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_head_tail_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.pdu_head_tail_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_head_tail_sptr self, std::string level)"""
        return _satellites_swig.pdu_head_tail_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_head_tail_sptr self) -> std::string"""
        return _satellites_swig.pdu_head_tail_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_head_tail_sptr self) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_head_tail_sptr self, int m)"""
        return _satellites_swig.pdu_head_tail_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_head_tail_sptr self)"""
        return _satellites_swig.pdu_head_tail_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_head_tail_sptr self) -> bool"""
        return _satellites_swig.pdu_head_tail_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_head_tail_sptr self, int m)"""
        return _satellites_swig.pdu_head_tail_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_head_tail_sptr self) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_head_tail_sptr self, int i) -> long"""
        return _satellites_swig.pdu_head_tail_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_head_tail_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_head_tail_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.pdu_head_tail_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_head_tail_sptr self, int i) -> long"""
        return _satellites_swig.pdu_head_tail_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_head_tail_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_head_tail_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.pdu_head_tail_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_head_tail_sptr self) -> float"""
        return _satellites_swig.pdu_head_tail_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_head_tail_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.pdu_head_tail_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_head_tail_sptr self)"""
        return _satellites_swig.pdu_head_tail_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_head_tail_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.pdu_head_tail_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_head_tail_sptr self) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_head_tail_sptr self) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_head_tail_sptr self, int priority) -> int"""
        return _satellites_swig.pdu_head_tail_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_head_tail_sptr self) -> std::string"""
        return _satellites_swig.pdu_head_tail_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_head_tail_sptr self) -> std::string"""
        return _satellites_swig.pdu_head_tail_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_head_tail_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_head_tail_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_head_tail_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_head_tail_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_head_tail_sptr self) -> long"""
        return _satellites_swig.pdu_head_tail_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_head_tail_sptr self) -> basic_block_sptr"""
        return _satellites_swig.pdu_head_tail_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_head_tail_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.pdu_head_tail_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_head_tail_sptr self) -> std::string"""
        return _satellites_swig.pdu_head_tail_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_head_tail_sptr self, std::string name)"""
        return _satellites_swig.pdu_head_tail_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_head_tail_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.pdu_head_tail_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_head_tail_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_head_tail_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_head_tail_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_head_tail_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_head_tail_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_head_tail_sptr_message_subscribers(self, which_port)

# Register pdu_head_tail_sptr in _satellites_swig:
_satellites_swig.pdu_head_tail_sptr_swigregister(pdu_head_tail_sptr)


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

class pdu_length_filter(object):
    r"""Proxy of C++ gr::satellites::pdu_length_filter 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(min: "int", max: "int") -> "gr::satellites::pdu_length_filter::sptr":
        r"""make(int min, int max) -> pdu_length_filter_sptr"""
        return _satellites_swig.pdu_length_filter_make(min, max)
    __swig_destroy__ = _satellites_swig.delete_pdu_length_filter

# Register pdu_length_filter in _satellites_swig:
_satellites_swig.pdu_length_filter_swigregister(pdu_length_filter)

def pdu_length_filter_make(min: "int", max: "int") -> "gr::satellites::pdu_length_filter::sptr":
    r"""pdu_length_filter_make(int min, int max) -> pdu_length_filter_sptr"""
    return _satellites_swig.pdu_length_filter_make(min, max)

class pdu_length_filter_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::pdu_length_filter > 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__(pdu_length_filter_sptr self) -> pdu_length_filter_sptr
        __init__(pdu_length_filter_sptr self, pdu_length_filter p) -> pdu_length_filter_sptr
        """
        _satellites_swig.pdu_length_filter_sptr_swiginit(self, _satellites_swig.new_pdu_length_filter_sptr(*args))

    def __deref__(self) -> "gr::satellites::pdu_length_filter *":
        r"""__deref__(pdu_length_filter_sptr self) -> pdu_length_filter"""
        return _satellites_swig.pdu_length_filter_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_pdu_length_filter_sptr

    def make(self, min: "int", max: "int") -> "gr::satellites::pdu_length_filter::sptr":
        r"""make(pdu_length_filter_sptr self, int min, int max) -> pdu_length_filter_sptr"""
        return _satellites_swig.pdu_length_filter_sptr_make(self, min, max)

    def history(self) -> "unsigned int":
        r"""history(pdu_length_filter_sptr self) -> unsigned int"""
        return _satellites_swig.pdu_length_filter_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_length_filter_sptr self, int which, int delay)
        declare_sample_delay(pdu_length_filter_sptr self, unsigned int delay)
        """
        return _satellites_swig.pdu_length_filter_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_length_filter_sptr self, int which) -> unsigned int"""
        return _satellites_swig.pdu_length_filter_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_length_filter_sptr self, int multiple)"""
        return _satellites_swig.pdu_length_filter_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_length_filter_sptr self) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_length_filter_sptr self) -> double"""
        return _satellites_swig.pdu_length_filter_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_length_filter_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_length_filter_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_length_filter_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_length_filter_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_length_filter_sptr self) -> bool"""
        return _satellites_swig.pdu_length_filter_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_length_filter_sptr self) -> bool"""
        return _satellites_swig.pdu_length_filter_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_length_filter_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.pdu_length_filter_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_length_filter_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.pdu_length_filter_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_length_filter_sptr self, std::string level)"""
        return _satellites_swig.pdu_length_filter_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_length_filter_sptr self) -> std::string"""
        return _satellites_swig.pdu_length_filter_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_length_filter_sptr self) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_length_filter_sptr self, int m)"""
        return _satellites_swig.pdu_length_filter_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_length_filter_sptr self)"""
        return _satellites_swig.pdu_length_filter_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_length_filter_sptr self) -> bool"""
        return _satellites_swig.pdu_length_filter_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_length_filter_sptr self, int m)"""
        return _satellites_swig.pdu_length_filter_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_length_filter_sptr self) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_length_filter_sptr self, int i) -> long"""
        return _satellites_swig.pdu_length_filter_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_length_filter_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_length_filter_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.pdu_length_filter_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_length_filter_sptr self, int i) -> long"""
        return _satellites_swig.pdu_length_filter_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_length_filter_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_length_filter_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.pdu_length_filter_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_length_filter_sptr self) -> float"""
        return _satellites_swig.pdu_length_filter_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_length_filter_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.pdu_length_filter_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_length_filter_sptr self)"""
        return _satellites_swig.pdu_length_filter_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_length_filter_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.pdu_length_filter_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_length_filter_sptr self) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_length_filter_sptr self) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_length_filter_sptr self, int priority) -> int"""
        return _satellites_swig.pdu_length_filter_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_length_filter_sptr self) -> std::string"""
        return _satellites_swig.pdu_length_filter_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_length_filter_sptr self) -> std::string"""
        return _satellites_swig.pdu_length_filter_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_length_filter_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_length_filter_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_length_filter_sptr self) -> io_signature_sptr"""
        return _satellites_swig.pdu_length_filter_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_length_filter_sptr self) -> long"""
        return _satellites_swig.pdu_length_filter_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_length_filter_sptr self) -> basic_block_sptr"""
        return _satellites_swig.pdu_length_filter_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_length_filter_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.pdu_length_filter_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_length_filter_sptr self) -> std::string"""
        return _satellites_swig.pdu_length_filter_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_length_filter_sptr self, std::string name)"""
        return _satellites_swig.pdu_length_filter_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_length_filter_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.pdu_length_filter_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_length_filter_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_length_filter_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_length_filter_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_length_filter_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_length_filter_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.pdu_length_filter_sptr_message_subscribers(self, which_port)

# Register pdu_length_filter_sptr in _satellites_swig:
_satellites_swig.pdu_length_filter_sptr_swigregister(pdu_length_filter_sptr)


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

class u482c_decode(object):
    r"""Proxy of C++ gr::satellites::u482c_decode 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(verbose: "bool", viterbi: "int", scrambler: "int", rs: "int") -> "gr::satellites::u482c_decode::sptr":
        r"""make(bool verbose, int viterbi, int scrambler, int rs) -> u482c_decode_sptr"""
        return _satellites_swig.u482c_decode_make(verbose, viterbi, scrambler, rs)
    __swig_destroy__ = _satellites_swig.delete_u482c_decode

# Register u482c_decode in _satellites_swig:
_satellites_swig.u482c_decode_swigregister(u482c_decode)

def u482c_decode_make(verbose: "bool", viterbi: "int", scrambler: "int", rs: "int") -> "gr::satellites::u482c_decode::sptr":
    r"""u482c_decode_make(bool verbose, int viterbi, int scrambler, int rs) -> u482c_decode_sptr"""
    return _satellites_swig.u482c_decode_make(verbose, viterbi, scrambler, rs)

class u482c_decode_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::u482c_decode > 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__(u482c_decode_sptr self) -> u482c_decode_sptr
        __init__(u482c_decode_sptr self, u482c_decode p) -> u482c_decode_sptr
        """
        _satellites_swig.u482c_decode_sptr_swiginit(self, _satellites_swig.new_u482c_decode_sptr(*args))

    def __deref__(self) -> "gr::satellites::u482c_decode *":
        r"""__deref__(u482c_decode_sptr self) -> u482c_decode"""
        return _satellites_swig.u482c_decode_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_u482c_decode_sptr

    def make(self, verbose: "bool", viterbi: "int", scrambler: "int", rs: "int") -> "gr::satellites::u482c_decode::sptr":
        r"""make(u482c_decode_sptr self, bool verbose, int viterbi, int scrambler, int rs) -> u482c_decode_sptr"""
        return _satellites_swig.u482c_decode_sptr_make(self, verbose, viterbi, scrambler, rs)

    def history(self) -> "unsigned int":
        r"""history(u482c_decode_sptr self) -> unsigned int"""
        return _satellites_swig.u482c_decode_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(u482c_decode_sptr self, int which, int delay)
        declare_sample_delay(u482c_decode_sptr self, unsigned int delay)
        """
        return _satellites_swig.u482c_decode_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(u482c_decode_sptr self, int which) -> unsigned int"""
        return _satellites_swig.u482c_decode_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(u482c_decode_sptr self, int multiple)"""
        return _satellites_swig.u482c_decode_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(u482c_decode_sptr self) -> int"""
        return _satellites_swig.u482c_decode_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(u482c_decode_sptr self) -> double"""
        return _satellites_swig.u482c_decode_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(u482c_decode_sptr self) -> uint64_t"""
        return _satellites_swig.u482c_decode_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(u482c_decode_sptr self) -> uint64_t"""
        return _satellites_swig.u482c_decode_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(u482c_decode_sptr self) -> bool"""
        return _satellites_swig.u482c_decode_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(u482c_decode_sptr self) -> bool"""
        return _satellites_swig.u482c_decode_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(u482c_decode_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.u482c_decode_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(u482c_decode_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.u482c_decode_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(u482c_decode_sptr self, std::string level)"""
        return _satellites_swig.u482c_decode_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(u482c_decode_sptr self) -> std::string"""
        return _satellites_swig.u482c_decode_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(u482c_decode_sptr self) -> int"""
        return _satellites_swig.u482c_decode_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(u482c_decode_sptr self, int m)"""
        return _satellites_swig.u482c_decode_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(u482c_decode_sptr self)"""
        return _satellites_swig.u482c_decode_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(u482c_decode_sptr self) -> bool"""
        return _satellites_swig.u482c_decode_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(u482c_decode_sptr self, int m)"""
        return _satellites_swig.u482c_decode_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(u482c_decode_sptr self) -> int"""
        return _satellites_swig.u482c_decode_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(u482c_decode_sptr self, int i) -> long"""
        return _satellites_swig.u482c_decode_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(u482c_decode_sptr self, long max_output_buffer)
        set_max_output_buffer(u482c_decode_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.u482c_decode_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(u482c_decode_sptr self, int i) -> long"""
        return _satellites_swig.u482c_decode_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(u482c_decode_sptr self, long min_output_buffer)
        set_min_output_buffer(u482c_decode_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.u482c_decode_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(u482c_decode_sptr self) -> float"""
        return _satellites_swig.u482c_decode_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(u482c_decode_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.u482c_decode_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(u482c_decode_sptr self)"""
        return _satellites_swig.u482c_decode_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(u482c_decode_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.u482c_decode_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(u482c_decode_sptr self) -> int"""
        return _satellites_swig.u482c_decode_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(u482c_decode_sptr self) -> int"""
        return _satellites_swig.u482c_decode_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(u482c_decode_sptr self, int priority) -> int"""
        return _satellites_swig.u482c_decode_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(u482c_decode_sptr self) -> std::string"""
        return _satellites_swig.u482c_decode_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(u482c_decode_sptr self) -> std::string"""
        return _satellites_swig.u482c_decode_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(u482c_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.u482c_decode_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(u482c_decode_sptr self) -> io_signature_sptr"""
        return _satellites_swig.u482c_decode_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(u482c_decode_sptr self) -> long"""
        return _satellites_swig.u482c_decode_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(u482c_decode_sptr self) -> basic_block_sptr"""
        return _satellites_swig.u482c_decode_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(u482c_decode_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.u482c_decode_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(u482c_decode_sptr self) -> std::string"""
        return _satellites_swig.u482c_decode_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(u482c_decode_sptr self, std::string name)"""
        return _satellites_swig.u482c_decode_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(u482c_decode_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.u482c_decode_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(u482c_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.u482c_decode_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(u482c_decode_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.u482c_decode_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(u482c_decode_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.u482c_decode_sptr_message_subscribers(self, which_port)

# Register u482c_decode_sptr in _satellites_swig:
_satellites_swig.u482c_decode_sptr_swigregister(u482c_decode_sptr)


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

class varlen_packet_framer(object):
    r"""Proxy of C++ gr::satellites::varlen_packet_framer 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(packet_key: "std::string const &", length_field_size: "int", endianness: "gr::endianness_t", use_golay: "bool", sync_word: "std::vector< uint8_t,std::allocator< uint8_t > > const") -> "gr::satellites::varlen_packet_framer::sptr":
        r"""make(std::string const & packet_key, int length_field_size, gr::endianness_t endianness, bool use_golay, std::vector< uint8_t,std::allocator< uint8_t > > const sync_word) -> varlen_packet_framer_sptr"""
        return _satellites_swig.varlen_packet_framer_make(packet_key, length_field_size, endianness, use_golay, sync_word)
    __swig_destroy__ = _satellites_swig.delete_varlen_packet_framer

# Register varlen_packet_framer in _satellites_swig:
_satellites_swig.varlen_packet_framer_swigregister(varlen_packet_framer)

def varlen_packet_framer_make(packet_key: "std::string const &", length_field_size: "int", endianness: "gr::endianness_t", use_golay: "bool", sync_word: "std::vector< uint8_t,std::allocator< uint8_t > > const") -> "gr::satellites::varlen_packet_framer::sptr":
    r"""varlen_packet_framer_make(std::string const & packet_key, int length_field_size, gr::endianness_t endianness, bool use_golay, std::vector< uint8_t,std::allocator< uint8_t > > const sync_word) -> varlen_packet_framer_sptr"""
    return _satellites_swig.varlen_packet_framer_make(packet_key, length_field_size, endianness, use_golay, sync_word)

class varlen_packet_framer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::varlen_packet_framer > 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__(varlen_packet_framer_sptr self) -> varlen_packet_framer_sptr
        __init__(varlen_packet_framer_sptr self, varlen_packet_framer p) -> varlen_packet_framer_sptr
        """
        _satellites_swig.varlen_packet_framer_sptr_swiginit(self, _satellites_swig.new_varlen_packet_framer_sptr(*args))

    def __deref__(self) -> "gr::satellites::varlen_packet_framer *":
        r"""__deref__(varlen_packet_framer_sptr self) -> varlen_packet_framer"""
        return _satellites_swig.varlen_packet_framer_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_varlen_packet_framer_sptr

    def make(self, packet_key: "std::string const &", length_field_size: "int", endianness: "gr::endianness_t", use_golay: "bool", sync_word: "std::vector< uint8_t,std::allocator< uint8_t > > const") -> "gr::satellites::varlen_packet_framer::sptr":
        r"""make(varlen_packet_framer_sptr self, std::string const & packet_key, int length_field_size, gr::endianness_t endianness, bool use_golay, std::vector< uint8_t,std::allocator< uint8_t > > const sync_word) -> varlen_packet_framer_sptr"""
        return _satellites_swig.varlen_packet_framer_sptr_make(self, packet_key, length_field_size, endianness, use_golay, sync_word)

    def history(self) -> "unsigned int":
        r"""history(varlen_packet_framer_sptr self) -> unsigned int"""
        return _satellites_swig.varlen_packet_framer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(varlen_packet_framer_sptr self, int which, int delay)
        declare_sample_delay(varlen_packet_framer_sptr self, unsigned int delay)
        """
        return _satellites_swig.varlen_packet_framer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(varlen_packet_framer_sptr self, int which) -> unsigned int"""
        return _satellites_swig.varlen_packet_framer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(varlen_packet_framer_sptr self, int multiple)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(varlen_packet_framer_sptr self) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(varlen_packet_framer_sptr self) -> double"""
        return _satellites_swig.varlen_packet_framer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(varlen_packet_framer_sptr self) -> uint64_t"""
        return _satellites_swig.varlen_packet_framer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(varlen_packet_framer_sptr self) -> uint64_t"""
        return _satellites_swig.varlen_packet_framer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(varlen_packet_framer_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_framer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(varlen_packet_framer_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_framer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(varlen_packet_framer_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.varlen_packet_framer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(varlen_packet_framer_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.varlen_packet_framer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(varlen_packet_framer_sptr self, std::string level)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(varlen_packet_framer_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_framer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(varlen_packet_framer_sptr self) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(varlen_packet_framer_sptr self, int m)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(varlen_packet_framer_sptr self)"""
        return _satellites_swig.varlen_packet_framer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(varlen_packet_framer_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_framer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(varlen_packet_framer_sptr self, int m)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(varlen_packet_framer_sptr self) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(varlen_packet_framer_sptr self, int i) -> long"""
        return _satellites_swig.varlen_packet_framer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(varlen_packet_framer_sptr self, long max_output_buffer)
        set_max_output_buffer(varlen_packet_framer_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.varlen_packet_framer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(varlen_packet_framer_sptr self, int i) -> long"""
        return _satellites_swig.varlen_packet_framer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(varlen_packet_framer_sptr self, long min_output_buffer)
        set_min_output_buffer(varlen_packet_framer_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.varlen_packet_framer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(varlen_packet_framer_sptr self) -> float"""
        return _satellites_swig.varlen_packet_framer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(varlen_packet_framer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(varlen_packet_framer_sptr self)"""
        return _satellites_swig.varlen_packet_framer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(varlen_packet_framer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.varlen_packet_framer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(varlen_packet_framer_sptr self) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(varlen_packet_framer_sptr self) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(varlen_packet_framer_sptr self, int priority) -> int"""
        return _satellites_swig.varlen_packet_framer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(varlen_packet_framer_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_framer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(varlen_packet_framer_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_framer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(varlen_packet_framer_sptr self) -> io_signature_sptr"""
        return _satellites_swig.varlen_packet_framer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(varlen_packet_framer_sptr self) -> io_signature_sptr"""
        return _satellites_swig.varlen_packet_framer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(varlen_packet_framer_sptr self) -> long"""
        return _satellites_swig.varlen_packet_framer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(varlen_packet_framer_sptr self) -> basic_block_sptr"""
        return _satellites_swig.varlen_packet_framer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(varlen_packet_framer_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.varlen_packet_framer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(varlen_packet_framer_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_framer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(varlen_packet_framer_sptr self, std::string name)"""
        return _satellites_swig.varlen_packet_framer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(varlen_packet_framer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.varlen_packet_framer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(varlen_packet_framer_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_framer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(varlen_packet_framer_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_framer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(varlen_packet_framer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_framer_sptr_message_subscribers(self, which_port)

# Register varlen_packet_framer_sptr in _satellites_swig:
_satellites_swig.varlen_packet_framer_sptr_swigregister(varlen_packet_framer_sptr)


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

class varlen_packet_tagger(object):
    r"""Proxy of C++ gr::satellites::varlen_packet_tagger 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(sync_key: "std::string const &", packet_key: "std::string const &", length_field_size: "int", max_packet_size: "int", endianness: "gr::endianness_t", use_golay: "bool") -> "gr::satellites::varlen_packet_tagger::sptr":
        r"""make(std::string const & sync_key, std::string const & packet_key, int length_field_size, int max_packet_size, gr::endianness_t endianness, bool use_golay) -> varlen_packet_tagger_sptr"""
        return _satellites_swig.varlen_packet_tagger_make(sync_key, packet_key, length_field_size, max_packet_size, endianness, use_golay)
    __swig_destroy__ = _satellites_swig.delete_varlen_packet_tagger

# Register varlen_packet_tagger in _satellites_swig:
_satellites_swig.varlen_packet_tagger_swigregister(varlen_packet_tagger)

def varlen_packet_tagger_make(sync_key: "std::string const &", packet_key: "std::string const &", length_field_size: "int", max_packet_size: "int", endianness: "gr::endianness_t", use_golay: "bool") -> "gr::satellites::varlen_packet_tagger::sptr":
    r"""varlen_packet_tagger_make(std::string const & sync_key, std::string const & packet_key, int length_field_size, int max_packet_size, gr::endianness_t endianness, bool use_golay) -> varlen_packet_tagger_sptr"""
    return _satellites_swig.varlen_packet_tagger_make(sync_key, packet_key, length_field_size, max_packet_size, endianness, use_golay)

class varlen_packet_tagger_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::varlen_packet_tagger > 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__(varlen_packet_tagger_sptr self) -> varlen_packet_tagger_sptr
        __init__(varlen_packet_tagger_sptr self, varlen_packet_tagger p) -> varlen_packet_tagger_sptr
        """
        _satellites_swig.varlen_packet_tagger_sptr_swiginit(self, _satellites_swig.new_varlen_packet_tagger_sptr(*args))

    def __deref__(self) -> "gr::satellites::varlen_packet_tagger *":
        r"""__deref__(varlen_packet_tagger_sptr self) -> varlen_packet_tagger"""
        return _satellites_swig.varlen_packet_tagger_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_varlen_packet_tagger_sptr

    def make(self, sync_key: "std::string const &", packet_key: "std::string const &", length_field_size: "int", max_packet_size: "int", endianness: "gr::endianness_t", use_golay: "bool") -> "gr::satellites::varlen_packet_tagger::sptr":
        r"""make(varlen_packet_tagger_sptr self, std::string const & sync_key, std::string const & packet_key, int length_field_size, int max_packet_size, gr::endianness_t endianness, bool use_golay) -> varlen_packet_tagger_sptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_make(self, sync_key, packet_key, length_field_size, max_packet_size, endianness, use_golay)

    def history(self) -> "unsigned int":
        r"""history(varlen_packet_tagger_sptr self) -> unsigned int"""
        return _satellites_swig.varlen_packet_tagger_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(varlen_packet_tagger_sptr self, int which, int delay)
        declare_sample_delay(varlen_packet_tagger_sptr self, unsigned int delay)
        """
        return _satellites_swig.varlen_packet_tagger_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(varlen_packet_tagger_sptr self, int which) -> unsigned int"""
        return _satellites_swig.varlen_packet_tagger_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(varlen_packet_tagger_sptr self, int multiple)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(varlen_packet_tagger_sptr self) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(varlen_packet_tagger_sptr self) -> double"""
        return _satellites_swig.varlen_packet_tagger_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(varlen_packet_tagger_sptr self) -> uint64_t"""
        return _satellites_swig.varlen_packet_tagger_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(varlen_packet_tagger_sptr self) -> uint64_t"""
        return _satellites_swig.varlen_packet_tagger_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(varlen_packet_tagger_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_tagger_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(varlen_packet_tagger_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_tagger_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(varlen_packet_tagger_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.varlen_packet_tagger_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(varlen_packet_tagger_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.varlen_packet_tagger_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(varlen_packet_tagger_sptr self, std::string level)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(varlen_packet_tagger_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_tagger_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(varlen_packet_tagger_sptr self) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(varlen_packet_tagger_sptr self, int m)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(varlen_packet_tagger_sptr self)"""
        return _satellites_swig.varlen_packet_tagger_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(varlen_packet_tagger_sptr self) -> bool"""
        return _satellites_swig.varlen_packet_tagger_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(varlen_packet_tagger_sptr self, int m)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(varlen_packet_tagger_sptr self) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(varlen_packet_tagger_sptr self, int i) -> long"""
        return _satellites_swig.varlen_packet_tagger_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(varlen_packet_tagger_sptr self, long max_output_buffer)
        set_max_output_buffer(varlen_packet_tagger_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.varlen_packet_tagger_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(varlen_packet_tagger_sptr self, int i) -> long"""
        return _satellites_swig.varlen_packet_tagger_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(varlen_packet_tagger_sptr self, long min_output_buffer)
        set_min_output_buffer(varlen_packet_tagger_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.varlen_packet_tagger_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(varlen_packet_tagger_sptr self) -> float"""
        return _satellites_swig.varlen_packet_tagger_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(varlen_packet_tagger_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(varlen_packet_tagger_sptr self)"""
        return _satellites_swig.varlen_packet_tagger_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(varlen_packet_tagger_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.varlen_packet_tagger_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(varlen_packet_tagger_sptr self) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(varlen_packet_tagger_sptr self) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(varlen_packet_tagger_sptr self, int priority) -> int"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(varlen_packet_tagger_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_tagger_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(varlen_packet_tagger_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_tagger_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(varlen_packet_tagger_sptr self) -> io_signature_sptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(varlen_packet_tagger_sptr self) -> io_signature_sptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(varlen_packet_tagger_sptr self) -> long"""
        return _satellites_swig.varlen_packet_tagger_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(varlen_packet_tagger_sptr self) -> basic_block_sptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(varlen_packet_tagger_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.varlen_packet_tagger_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(varlen_packet_tagger_sptr self) -> std::string"""
        return _satellites_swig.varlen_packet_tagger_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(varlen_packet_tagger_sptr self, std::string name)"""
        return _satellites_swig.varlen_packet_tagger_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(varlen_packet_tagger_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.varlen_packet_tagger_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(varlen_packet_tagger_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(varlen_packet_tagger_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(varlen_packet_tagger_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.varlen_packet_tagger_sptr_message_subscribers(self, which_port)

# Register varlen_packet_tagger_sptr in _satellites_swig:
_satellites_swig.varlen_packet_tagger_sptr_swigregister(varlen_packet_tagger_sptr)


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

class viterbi_decoder(object):
    r"""Proxy of C++ gr::satellites::viterbi_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(constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::viterbi_decoder::sptr":
        r"""make(int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> viterbi_decoder_sptr"""
        return _satellites_swig.viterbi_decoder_make(constraint, polynomials)
    __swig_destroy__ = _satellites_swig.delete_viterbi_decoder

# Register viterbi_decoder in _satellites_swig:
_satellites_swig.viterbi_decoder_swigregister(viterbi_decoder)

def viterbi_decoder_make(constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::viterbi_decoder::sptr":
    r"""viterbi_decoder_make(int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> viterbi_decoder_sptr"""
    return _satellites_swig.viterbi_decoder_make(constraint, polynomials)

class viterbi_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::viterbi_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__(viterbi_decoder_sptr self) -> viterbi_decoder_sptr
        __init__(viterbi_decoder_sptr self, viterbi_decoder p) -> viterbi_decoder_sptr
        """
        _satellites_swig.viterbi_decoder_sptr_swiginit(self, _satellites_swig.new_viterbi_decoder_sptr(*args))

    def __deref__(self) -> "gr::satellites::viterbi_decoder *":
        r"""__deref__(viterbi_decoder_sptr self) -> viterbi_decoder"""
        return _satellites_swig.viterbi_decoder_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_viterbi_decoder_sptr

    def make(self, constraint: "int", polynomials: "std::vector< int,std::allocator< int > > const &") -> "gr::satellites::viterbi_decoder::sptr":
        r"""make(viterbi_decoder_sptr self, int constraint, std::vector< int,std::allocator< int > > const & polynomials) -> viterbi_decoder_sptr"""
        return _satellites_swig.viterbi_decoder_sptr_make(self, constraint, polynomials)

    def history(self) -> "unsigned int":
        r"""history(viterbi_decoder_sptr self) -> unsigned int"""
        return _satellites_swig.viterbi_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(viterbi_decoder_sptr self, int which, int delay)
        declare_sample_delay(viterbi_decoder_sptr self, unsigned int delay)
        """
        return _satellites_swig.viterbi_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(viterbi_decoder_sptr self, int which) -> unsigned int"""
        return _satellites_swig.viterbi_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(viterbi_decoder_sptr self, int multiple)"""
        return _satellites_swig.viterbi_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(viterbi_decoder_sptr self) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(viterbi_decoder_sptr self) -> double"""
        return _satellites_swig.viterbi_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(viterbi_decoder_sptr self) -> uint64_t"""
        return _satellites_swig.viterbi_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(viterbi_decoder_sptr self) -> uint64_t"""
        return _satellites_swig.viterbi_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(viterbi_decoder_sptr self) -> bool"""
        return _satellites_swig.viterbi_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(viterbi_decoder_sptr self) -> bool"""
        return _satellites_swig.viterbi_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(viterbi_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _satellites_swig.viterbi_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(viterbi_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _satellites_swig.viterbi_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(viterbi_decoder_sptr self, std::string level)"""
        return _satellites_swig.viterbi_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(viterbi_decoder_sptr self) -> std::string"""
        return _satellites_swig.viterbi_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(viterbi_decoder_sptr self) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(viterbi_decoder_sptr self, int m)"""
        return _satellites_swig.viterbi_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(viterbi_decoder_sptr self)"""
        return _satellites_swig.viterbi_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(viterbi_decoder_sptr self) -> bool"""
        return _satellites_swig.viterbi_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(viterbi_decoder_sptr self, int m)"""
        return _satellites_swig.viterbi_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(viterbi_decoder_sptr self) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(viterbi_decoder_sptr self, int i) -> long"""
        return _satellites_swig.viterbi_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(viterbi_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(viterbi_decoder_sptr self, int port, long max_output_buffer)
        """
        return _satellites_swig.viterbi_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(viterbi_decoder_sptr self, int i) -> long"""
        return _satellites_swig.viterbi_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(viterbi_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(viterbi_decoder_sptr self, int port, long min_output_buffer)
        """
        return _satellites_swig.viterbi_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(viterbi_decoder_sptr self) -> float"""
        return _satellites_swig.viterbi_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(viterbi_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _satellites_swig.viterbi_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(viterbi_decoder_sptr self)"""
        return _satellites_swig.viterbi_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(viterbi_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _satellites_swig.viterbi_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(viterbi_decoder_sptr self) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(viterbi_decoder_sptr self) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(viterbi_decoder_sptr self, int priority) -> int"""
        return _satellites_swig.viterbi_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(viterbi_decoder_sptr self) -> std::string"""
        return _satellites_swig.viterbi_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(viterbi_decoder_sptr self) -> std::string"""
        return _satellites_swig.viterbi_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(viterbi_decoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.viterbi_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(viterbi_decoder_sptr self) -> io_signature_sptr"""
        return _satellites_swig.viterbi_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(viterbi_decoder_sptr self) -> long"""
        return _satellites_swig.viterbi_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(viterbi_decoder_sptr self) -> basic_block_sptr"""
        return _satellites_swig.viterbi_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(viterbi_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _satellites_swig.viterbi_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(viterbi_decoder_sptr self) -> std::string"""
        return _satellites_swig.viterbi_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(viterbi_decoder_sptr self, std::string name)"""
        return _satellites_swig.viterbi_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(viterbi_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _satellites_swig.viterbi_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(viterbi_decoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.viterbi_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(viterbi_decoder_sptr self) -> swig_pmt_ptr"""
        return _satellites_swig.viterbi_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(viterbi_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _satellites_swig.viterbi_decoder_sptr_message_subscribers(self, which_port)

# Register viterbi_decoder_sptr in _satellites_swig:
_satellites_swig.viterbi_decoder_sptr_swigregister(viterbi_decoder_sptr)


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



