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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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()
byte_t = _satellites_swig.byte_t

float_t = _satellites_swig.float_t

complex_t = _satellites_swig.complex_t


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

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

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

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

def type_from_pmt(vector: "swig_pmt_ptr") -> "gr::blocks::pdu::vector_type":
    r"""type_from_pmt(swig_pmt_ptr vector) -> gr::blocks::pdu::vector_type"""
    return _satellites_swig.type_from_pmt(vector)
class ax100_decode(object):
    r"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::ax100_decode.

    To avoid accidental use of raw pointers, satellites::ax100_decode's constructor is in a private implementation class. satellites::ax100_decode::make is the public interface for creating new instances.

    Args:
        verbose : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::ax100_decode.

        To avoid accidental use of raw pointers, satellites::ax100_decode's constructor is in a private implementation class. satellites::ax100_decode::make is the public interface for creating new instances.

        Args:
            verbose : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::ax100_decode.

        To avoid accidental use of raw pointers, satellites::ax100_decode's constructor is in a private implementation class. satellites::ax100_decode::make is the public interface for creating new instances.

        Args:
            verbose : 
        """
        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 costas_loop_8apsk_cc(object):
    r"""
    8APSK Costas Loop

    Constructor Specific Documentation:

    Make an 8APSK Costas Loop block.

    Args:
        loop_bw : internal 2nd order loop bandwidth
    """

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

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

    @staticmethod
    def make(loop_bw: "float") -> "gr::satellites::costas_loop_8apsk_cc::sptr":
        r"""
        make(float loop_bw) -> costas_loop_8apsk_cc_sptr
        8APSK Costas Loop

        Constructor Specific Documentation:

        Make an 8APSK Costas Loop block.

        Args:
            loop_bw : internal 2nd order loop bandwidth
        """
        return _satellites_swig.costas_loop_8apsk_cc_make(loop_bw)

    def error(self) -> "float":
        r"""
        error(costas_loop_8apsk_cc self) -> float
        Returns the current value of the loop error.
        """
        return _satellites_swig.costas_loop_8apsk_cc_error(self)
    __swig_destroy__ = _satellites_swig.delete_costas_loop_8apsk_cc

# Register costas_loop_8apsk_cc in _satellites_swig:
_satellites_swig.costas_loop_8apsk_cc_swigregister(costas_loop_8apsk_cc)
class costas_loop_8apsk_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::costas_loop_8apsk_cc > class."""

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

    def __init__(self, *args):
        r"""
        __init__(costas_loop_8apsk_cc_sptr self) -> costas_loop_8apsk_cc_sptr
        __init__(costas_loop_8apsk_cc_sptr self, costas_loop_8apsk_cc p) -> costas_loop_8apsk_cc_sptr
        """
        _satellites_swig.costas_loop_8apsk_cc_sptr_swiginit(self, _satellites_swig.new_costas_loop_8apsk_cc_sptr(*args))

    def __deref__(self) -> "gr::satellites::costas_loop_8apsk_cc *":
        r"""__deref__(costas_loop_8apsk_cc_sptr self) -> costas_loop_8apsk_cc"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_costas_loop_8apsk_cc_sptr

    def make(self, loop_bw: "float") -> "gr::satellites::costas_loop_8apsk_cc::sptr":
        r"""
        make(costas_loop_8apsk_cc_sptr self, float loop_bw) -> costas_loop_8apsk_cc_sptr
        8APSK Costas Loop

        Constructor Specific Documentation:

        Make an 8APSK Costas Loop block.

        Args:
            loop_bw : internal 2nd order loop bandwidth
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_make(self, loop_bw)

    def error(self) -> "float":
        r"""
        error(costas_loop_8apsk_cc_sptr self) -> float
        Returns the current value of the loop error.
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_error(self)

    def history(self) -> "unsigned int":
        r"""history(costas_loop_8apsk_cc_sptr self) -> unsigned int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(costas_loop_8apsk_cc_sptr self) -> int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(costas_loop_8apsk_cc_sptr self) -> double"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(costas_loop_8apsk_cc_sptr self) -> uint64_t"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(costas_loop_8apsk_cc_sptr self) -> uint64_t"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(costas_loop_8apsk_cc_sptr self) -> bool"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(costas_loop_8apsk_cc_sptr self) -> bool"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(costas_loop_8apsk_cc_sptr self) -> std::string"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(costas_loop_8apsk_cc_sptr self) -> int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(costas_loop_8apsk_cc_sptr self)"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(costas_loop_8apsk_cc_sptr self) -> bool"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(costas_loop_8apsk_cc_sptr self) -> int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_input_buffers_full(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_output_buffers_full(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(costas_loop_8apsk_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(costas_loop_8apsk_cc_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(costas_loop_8apsk_cc_sptr self) -> float"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(costas_loop_8apsk_cc_sptr self)"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(costas_loop_8apsk_cc_sptr self) -> int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(costas_loop_8apsk_cc_sptr self) -> int"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(costas_loop_8apsk_cc_sptr self) -> std::string"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(costas_loop_8apsk_cc_sptr self) -> std::string"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(costas_loop_8apsk_cc_sptr self) -> long"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(costas_loop_8apsk_cc_sptr self) -> basic_block_sptr"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(costas_loop_8apsk_cc_sptr self) -> std::string"""
        return _satellites_swig.costas_loop_8apsk_cc_sptr_alias(self)

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

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

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

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

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

# Register costas_loop_8apsk_cc_sptr in _satellites_swig:
_satellites_swig.costas_loop_8apsk_cc_sptr_swigregister(costas_loop_8apsk_cc_sptr)

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

class convolutional_encoder(object):
    r"""
    Convolutional encoder.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::convolutional_encoder.

    To avoid accidental use of raw pointers, satellites::convolutional_encoder's constructor is in a private implementation class. satellites::convolutional_encoder::make is the public interface for creating new instances.

    Args:
        constraint : 
        polynomials : 
    """

    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
        Convolutional encoder.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::convolutional_encoder.

        To avoid accidental use of raw pointers, satellites::convolutional_encoder's constructor is in a private implementation class. satellites::convolutional_encoder::make is the public interface for creating new instances.

        Args:
            constraint : 
            polynomials : 
        """
        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)
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
        Convolutional encoder.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::convolutional_encoder.

        To avoid accidental use of raw pointers, satellites::convolutional_encoder's constructor is in a private implementation class. satellites::convolutional_encoder::make is the public interface for creating new instances.

        Args:
            constraint : 
            polynomials : 
        """
        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 crc(object):
    r"""
    Calculates a CRC.

    This class calculates a CRC with configurable parameters. A table-driven byte-by-byte approach is used in the CRC computation.
    """

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

    def __init__(self, num_bits: "unsigned int", poly: "uint64_t", initial_value: "uint64_t", final_xor: "uint64_t", input_reflected: "bool", result_reflected: "bool"):
        r"""
        __init__(crc self, unsigned int num_bits, uint64_t poly, uint64_t initial_value, uint64_t final_xor, bool input_reflected, bool result_reflected) -> crc
        Construct a CRC calculator instance.
        """
        _satellites_swig.crc_swiginit(self, _satellites_swig.new_crc(num_bits, poly, initial_value, final_xor, input_reflected, result_reflected))
    __swig_destroy__ = _satellites_swig.delete_crc

    def compute(self, *args) -> "uint64_t":
        r"""
        compute(crc self, uint8_t const * data, std::size_t len) -> uint64_t
        compute(crc self, std::vector< uint8_t,std::allocator< uint8_t > > const data) -> uint64_t
        Computes a CRC.
        """
        return _satellites_swig.crc_compute(self, *args)

# Register crc in _satellites_swig:
_satellites_swig.crc_swigregister(crc)
class crc_append(object):
    r"""
    Calculates and appends a CRC to a PDU.

    The CRC append block receives a PDU, calculates the CRC of the PDU data, appends it to the PDU, and sends that as its output. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

    Constructor Specific Documentation:

    Build the CRC append block.

    Args:
        num_bits : CRC size in bits (must be a multiple of 8)
        poly : CRC polynomial, in MSB-first notation
        initial_value : Initial register value
        final_xor : Final XOR value
        input_reflected : true if the input is LSB-first, false if not
        result_reflected : true if the output is LSB-first, false if not
        swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
        skip_header_bytes : gives the number of header byte to skip in the CRC calculation
    """

    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(num_bits: "unsigned int", poly: "uint64_t", initial_value: "uint64_t", final_xor: "uint64_t", input_reflected: "bool", result_reflected: "bool", swap_endianness: "bool", skip_header_bytes: "unsigned int"=0) -> "gr::satellites::crc_append::sptr":
        r"""
        make(unsigned int num_bits, uint64_t poly, uint64_t initial_value, uint64_t final_xor, bool input_reflected, bool result_reflected, bool swap_endianness, unsigned int skip_header_bytes=0) -> crc_append_sptr
        Calculates and appends a CRC to a PDU.

        The CRC append block receives a PDU, calculates the CRC of the PDU data, appends it to the PDU, and sends that as its output. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

        Constructor Specific Documentation:

        Build the CRC append block.

        Args:
            num_bits : CRC size in bits (must be a multiple of 8)
            poly : CRC polynomial, in MSB-first notation
            initial_value : Initial register value
            final_xor : Final XOR value
            input_reflected : true if the input is LSB-first, false if not
            result_reflected : true if the output is LSB-first, false if not
            swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
            skip_header_bytes : gives the number of header byte to skip in the CRC calculation
        """
        return _satellites_swig.crc_append_make(num_bits, poly, initial_value, final_xor, input_reflected, result_reflected, swap_endianness, skip_header_bytes)
    __swig_destroy__ = _satellites_swig.delete_crc_append

# Register crc_append in _satellites_swig:
_satellites_swig.crc_append_swigregister(crc_append)
class crc_append_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::crc_append > 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__(crc_append_sptr self) -> crc_append_sptr
        __init__(crc_append_sptr self, crc_append p) -> crc_append_sptr
        """
        _satellites_swig.crc_append_sptr_swiginit(self, _satellites_swig.new_crc_append_sptr(*args))

    def __deref__(self) -> "gr::satellites::crc_append *":
        r"""__deref__(crc_append_sptr self) -> crc_append"""
        return _satellites_swig.crc_append_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_crc_append_sptr

    def make(self, num_bits: "unsigned int", poly: "uint64_t", initial_value: "uint64_t", final_xor: "uint64_t", input_reflected: "bool", result_reflected: "bool", swap_endianness: "bool", skip_header_bytes: "unsigned int"=0) -> "gr::satellites::crc_append::sptr":
        r"""
        make(crc_append_sptr self, unsigned int num_bits, uint64_t poly, uint64_t initial_value, uint64_t final_xor, bool input_reflected, bool result_reflected, bool swap_endianness, unsigned int skip_header_bytes=0) -> crc_append_sptr
        Calculates and appends a CRC to a PDU.

        The CRC append block receives a PDU, calculates the CRC of the PDU data, appends it to the PDU, and sends that as its output. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

        Constructor Specific Documentation:

        Build the CRC append block.

        Args:
            num_bits : CRC size in bits (must be a multiple of 8)
            poly : CRC polynomial, in MSB-first notation
            initial_value : Initial register value
            final_xor : Final XOR value
            input_reflected : true if the input is LSB-first, false if not
            result_reflected : true if the output is LSB-first, false if not
            swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
            skip_header_bytes : gives the number of header byte to skip in the CRC calculation
        """
        return _satellites_swig.crc_append_sptr_make(self, num_bits, poly, initial_value, final_xor, input_reflected, result_reflected, swap_endianness, skip_header_bytes)

    def history(self) -> "unsigned int":
        r"""history(crc_append_sptr self) -> unsigned int"""
        return _satellites_swig.crc_append_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(crc_append_sptr self) -> int"""
        return _satellites_swig.crc_append_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(crc_append_sptr self) -> double"""
        return _satellites_swig.crc_append_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(crc_append_sptr self) -> uint64_t"""
        return _satellites_swig.crc_append_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(crc_append_sptr self) -> uint64_t"""
        return _satellites_swig.crc_append_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(crc_append_sptr self) -> bool"""
        return _satellites_swig.crc_append_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(crc_append_sptr self) -> bool"""
        return _satellites_swig.crc_append_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(crc_append_sptr self) -> std::string"""
        return _satellites_swig.crc_append_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(crc_append_sptr self) -> int"""
        return _satellites_swig.crc_append_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(crc_append_sptr self)"""
        return _satellites_swig.crc_append_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(crc_append_sptr self) -> bool"""
        return _satellites_swig.crc_append_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(crc_append_sptr self) -> int"""
        return _satellites_swig.crc_append_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(crc_append_sptr self) -> float"""
        return _satellites_swig.crc_append_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(crc_append_sptr self)"""
        return _satellites_swig.crc_append_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(crc_append_sptr self) -> int"""
        return _satellites_swig.crc_append_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(crc_append_sptr self) -> int"""
        return _satellites_swig.crc_append_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(crc_append_sptr self) -> std::string"""
        return _satellites_swig.crc_append_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(crc_append_sptr self) -> std::string"""
        return _satellites_swig.crc_append_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(crc_append_sptr self) -> long"""
        return _satellites_swig.crc_append_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(crc_append_sptr self) -> basic_block_sptr"""
        return _satellites_swig.crc_append_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(crc_append_sptr self) -> std::string"""
        return _satellites_swig.crc_append_sptr_alias(self)

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

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

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

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

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

# Register crc_append_sptr in _satellites_swig:
_satellites_swig.crc_append_sptr_swigregister(crc_append_sptr)

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

class crc_check(object):
    r"""
    Check the CRC at the end of a PDU.

    The CRC append block receives a PDU containing a CRC at its end, and checks whether the CRC is correct. The PDU is sent over the ok or fail output ports according to the result of this check. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

    Constructor Specific Documentation:

    Build the CRC append block.

    Args:
        num_bits : CRC size in bits (must be a multiple of 8)
        poly : CRC polynomial, in MSB-first notation
        initial_value : Initial register value
        final_xor : Final XOR value
        input_reflected : true if the input is LSB-first, false if not
        result_reflected : true if the output is LSB-first, false if not
        swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
        discard_crc : If true, the CRC is removed from the PDU before sending it to the output port. If false, the CRC is preserved in the outupt PDU.
        skip_header_bytes : gives the number of header byte to skip in the CRC calculation
    """

    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(num_bits: "unsigned int", poly: "uint64_t", initial_value: "uint64_t", final_xor: "uint64_t", input_reflected: "bool", result_reflected: "bool", swap_endianness: "bool", discard_crc: "bool"=False, skip_header_bytes: "unsigned int"=0) -> "gr::satellites::crc_check::sptr":
        r"""
        make(unsigned int num_bits, uint64_t poly, uint64_t initial_value, uint64_t final_xor, bool input_reflected, bool result_reflected, bool swap_endianness, bool discard_crc=False, unsigned int skip_header_bytes=0) -> crc_check_sptr
        Check the CRC at the end of a PDU.

        The CRC append block receives a PDU containing a CRC at its end, and checks whether the CRC is correct. The PDU is sent over the ok or fail output ports according to the result of this check. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

        Constructor Specific Documentation:

        Build the CRC append block.

        Args:
            num_bits : CRC size in bits (must be a multiple of 8)
            poly : CRC polynomial, in MSB-first notation
            initial_value : Initial register value
            final_xor : Final XOR value
            input_reflected : true if the input is LSB-first, false if not
            result_reflected : true if the output is LSB-first, false if not
            swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
            discard_crc : If true, the CRC is removed from the PDU before sending it to the output port. If false, the CRC is preserved in the outupt PDU.
            skip_header_bytes : gives the number of header byte to skip in the CRC calculation
        """
        return _satellites_swig.crc_check_make(num_bits, poly, initial_value, final_xor, input_reflected, result_reflected, swap_endianness, discard_crc, skip_header_bytes)
    __swig_destroy__ = _satellites_swig.delete_crc_check

# Register crc_check in _satellites_swig:
_satellites_swig.crc_check_swigregister(crc_check)
class crc_check_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::crc_check > 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__(crc_check_sptr self) -> crc_check_sptr
        __init__(crc_check_sptr self, crc_check p) -> crc_check_sptr
        """
        _satellites_swig.crc_check_sptr_swiginit(self, _satellites_swig.new_crc_check_sptr(*args))

    def __deref__(self) -> "gr::satellites::crc_check *":
        r"""__deref__(crc_check_sptr self) -> crc_check"""
        return _satellites_swig.crc_check_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_crc_check_sptr

    def make(self, num_bits: "unsigned int", poly: "uint64_t", initial_value: "uint64_t", final_xor: "uint64_t", input_reflected: "bool", result_reflected: "bool", swap_endianness: "bool", discard_crc: "bool"=False, skip_header_bytes: "unsigned int"=0) -> "gr::satellites::crc_check::sptr":
        r"""
        make(crc_check_sptr self, unsigned int num_bits, uint64_t poly, uint64_t initial_value, uint64_t final_xor, bool input_reflected, bool result_reflected, bool swap_endianness, bool discard_crc=False, unsigned int skip_header_bytes=0) -> crc_check_sptr
        Check the CRC at the end of a PDU.

        The CRC append block receives a PDU containing a CRC at its end, and checks whether the CRC is correct. The PDU is sent over the ok or fail output ports according to the result of this check. It can support any CRC whose size is a multiple of 8 bits between 8 and 64 bits.

        Constructor Specific Documentation:

        Build the CRC append block.

        Args:
            num_bits : CRC size in bits (must be a multiple of 8)
            poly : CRC polynomial, in MSB-first notation
            initial_value : Initial register value
            final_xor : Final XOR value
            input_reflected : true if the input is LSB-first, false if not
            result_reflected : true if the output is LSB-first, false if not
            swap_endianness : true if the CRC is stored as little-endian in the PDU, false if not
            discard_crc : If true, the CRC is removed from the PDU before sending it to the output port. If false, the CRC is preserved in the outupt PDU.
            skip_header_bytes : gives the number of header byte to skip in the CRC calculation
        """
        return _satellites_swig.crc_check_sptr_make(self, num_bits, poly, initial_value, final_xor, input_reflected, result_reflected, swap_endianness, discard_crc, skip_header_bytes)

    def history(self) -> "unsigned int":
        r"""history(crc_check_sptr self) -> unsigned int"""
        return _satellites_swig.crc_check_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(crc_check_sptr self) -> int"""
        return _satellites_swig.crc_check_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(crc_check_sptr self) -> double"""
        return _satellites_swig.crc_check_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(crc_check_sptr self) -> uint64_t"""
        return _satellites_swig.crc_check_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(crc_check_sptr self) -> uint64_t"""
        return _satellites_swig.crc_check_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(crc_check_sptr self) -> bool"""
        return _satellites_swig.crc_check_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(crc_check_sptr self) -> bool"""
        return _satellites_swig.crc_check_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(crc_check_sptr self) -> std::string"""
        return _satellites_swig.crc_check_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(crc_check_sptr self) -> int"""
        return _satellites_swig.crc_check_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(crc_check_sptr self)"""
        return _satellites_swig.crc_check_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(crc_check_sptr self) -> bool"""
        return _satellites_swig.crc_check_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(crc_check_sptr self) -> int"""
        return _satellites_swig.crc_check_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(crc_check_sptr self) -> float"""
        return _satellites_swig.crc_check_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(crc_check_sptr self)"""
        return _satellites_swig.crc_check_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(crc_check_sptr self) -> int"""
        return _satellites_swig.crc_check_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(crc_check_sptr self) -> int"""
        return _satellites_swig.crc_check_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(crc_check_sptr self) -> std::string"""
        return _satellites_swig.crc_check_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(crc_check_sptr self) -> std::string"""
        return _satellites_swig.crc_check_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(crc_check_sptr self) -> long"""
        return _satellites_swig.crc_check_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(crc_check_sptr self) -> basic_block_sptr"""
        return _satellites_swig.crc_check_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(crc_check_sptr self) -> std::string"""
        return _satellites_swig.crc_check_sptr_alias(self)

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

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

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

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

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

# Register crc_check_sptr in _satellites_swig:
_satellites_swig.crc_check_sptr_swigregister(crc_check_sptr)

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

class decode_ra_code(object):
    r"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::decode_ra_code.

    To avoid accidental use of raw pointers, satellites::decode_ra_code's constructor is in a private implementation class. satellites::decode_ra_code::make is the public interface for creating new instances.

    Args:
        size : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::decode_ra_code.

        To avoid accidental use of raw pointers, satellites::decode_ra_code's constructor is in a private implementation class. satellites::decode_ra_code::make is the public interface for creating new instances.

        Args:
            size : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::decode_ra_code.

        To avoid accidental use of raw pointers, satellites::decode_ra_code's constructor is in a private implementation class. satellites::decode_ra_code::make is the public interface for creating new instances.

        Args:
            size : 
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::decode_rs.

    To avoid accidental use of raw pointers, satellites::decode_rs's constructor is in a private implementation class. satellites::decode_rs::make is the public interface for creating new instances.

    Args:
        dual_basis : 
        interleave : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::decode_rs.

        To avoid accidental use of raw pointers, satellites::decode_rs's constructor is in a private implementation class. satellites::decode_rs::make is the public interface for creating new instances.

        Args:
            dual_basis : 
            interleave : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::decode_rs.

        To avoid accidental use of raw pointers, satellites::decode_rs's constructor is in a private implementation class. satellites::decode_rs::make is the public interface for creating new instances.

        Args:
            dual_basis : 
            interleave : 
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::descrambler308.

    To avoid accidental use of raw pointers, satellites::descrambler308's constructor is in a private implementation class. satellites::descrambler308::make is the public interface for creating new instances.
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::descrambler308.

        To avoid accidental use of raw pointers, satellites::descrambler308's constructor is in a private implementation class. satellites::descrambler308::make is the public interface for creating new instances.
        """
        return _satellites_swig.descrambler308_make()
    __swig_destroy__ = _satellites_swig.delete_descrambler308

# Register descrambler308 in _satellites_swig:
_satellites_swig.descrambler308_swigregister(descrambler308)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::descrambler308.

        To avoid accidental use of raw pointers, satellites::descrambler308's constructor is in a private implementation class. satellites::descrambler308::make is the public interface for creating new instances.
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::distributed_syncframe_soft.

    To avoid accidental use of raw pointers, satellites::distributed_syncframe_soft's constructor is in a private implementation class. satellites::distributed_syncframe_soft::make is the public interface for creating new instances.

    Args:
        threshold : 
        syncword : 
        step : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::distributed_syncframe_soft.

        To avoid accidental use of raw pointers, satellites::distributed_syncframe_soft's constructor is in a private implementation class. satellites::distributed_syncframe_soft::make is the public interface for creating new instances.

        Args:
            threshold : 
            syncword : 
            step : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::distributed_syncframe_soft.

        To avoid accidental use of raw pointers, satellites::distributed_syncframe_soft's constructor is in a private implementation class. satellites::distributed_syncframe_soft::make is the public interface for creating new instances.

        Args:
            threshold : 
            syncword : 
            step : 
        """
        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 doppler_correction(object):
    r"""
    Performs Doppler correction using a frequency vs. time file.

    The Doppler Correction block uses a text file listing frequency vs. time to perform Doppler correction on its input signal. The same block can be used for Doppler simulation by inverting the frequency values in the input file or by taking the complex conjugate of the output of the block.


    The text file should contain lines with a timestamp and a frequency separated by a space. The timestamps are given in seconds, and typically consist of UNIX time. The t0 parameter in the block constructor gives the starting time, which is the timestamp corresponding to the first sample processed by the block. As long as the timestamps in the file and this timestamp are consistent, the block will work correctly. The frequencies are given in Hz.


    The block can also use time tags such as those generated by the UHD Source block to update its internal timestamp. In this case the timestamps in the file should use UNIX seconds, since the UHD timestamps also use UNIX seconds. When using UHD time tags, the t0 parameter can be left as 0.


    The Doppler correction block interpolates the frequency linearly between each pair of entries in the text file, and generates a correction with continuous phase.

    Constructor Specific Documentation:

    Build the Doppler Correction block.

    Args:
        filename : Path of the text file describing the Doppler data
        samp_rate : Sample rate
        t0 : Timestamp corresponding to the first sample
    """

    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(filename: "char const *", samp_rate: "double", t0: "double") -> "gr::satellites::doppler_correction::sptr":
        r"""
        make(char const * filename, double samp_rate, double t0) -> doppler_correction_sptr
        Performs Doppler correction using a frequency vs. time file.

        The Doppler Correction block uses a text file listing frequency vs. time to perform Doppler correction on its input signal. The same block can be used for Doppler simulation by inverting the frequency values in the input file or by taking the complex conjugate of the output of the block.


        The text file should contain lines with a timestamp and a frequency separated by a space. The timestamps are given in seconds, and typically consist of UNIX time. The t0 parameter in the block constructor gives the starting time, which is the timestamp corresponding to the first sample processed by the block. As long as the timestamps in the file and this timestamp are consistent, the block will work correctly. The frequencies are given in Hz.


        The block can also use time tags such as those generated by the UHD Source block to update its internal timestamp. In this case the timestamps in the file should use UNIX seconds, since the UHD timestamps also use UNIX seconds. When using UHD time tags, the t0 parameter can be left as 0.


        The Doppler correction block interpolates the frequency linearly between each pair of entries in the text file, and generates a correction with continuous phase.

        Constructor Specific Documentation:

        Build the Doppler Correction block.

        Args:
            filename : Path of the text file describing the Doppler data
            samp_rate : Sample rate
            t0 : Timestamp corresponding to the first sample
        """
        return _satellites_swig.doppler_correction_make(filename, samp_rate, t0)
    __swig_destroy__ = _satellites_swig.delete_doppler_correction

# Register doppler_correction in _satellites_swig:
_satellites_swig.doppler_correction_swigregister(doppler_correction)
class doppler_correction_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::doppler_correction > 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__(doppler_correction_sptr self) -> doppler_correction_sptr
        __init__(doppler_correction_sptr self, doppler_correction p) -> doppler_correction_sptr
        """
        _satellites_swig.doppler_correction_sptr_swiginit(self, _satellites_swig.new_doppler_correction_sptr(*args))

    def __deref__(self) -> "gr::satellites::doppler_correction *":
        r"""__deref__(doppler_correction_sptr self) -> doppler_correction"""
        return _satellites_swig.doppler_correction_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_doppler_correction_sptr

    def make(self, filename: "char const *", samp_rate: "double", t0: "double") -> "gr::satellites::doppler_correction::sptr":
        r"""
        make(doppler_correction_sptr self, char const * filename, double samp_rate, double t0) -> doppler_correction_sptr
        Performs Doppler correction using a frequency vs. time file.

        The Doppler Correction block uses a text file listing frequency vs. time to perform Doppler correction on its input signal. The same block can be used for Doppler simulation by inverting the frequency values in the input file or by taking the complex conjugate of the output of the block.


        The text file should contain lines with a timestamp and a frequency separated by a space. The timestamps are given in seconds, and typically consist of UNIX time. The t0 parameter in the block constructor gives the starting time, which is the timestamp corresponding to the first sample processed by the block. As long as the timestamps in the file and this timestamp are consistent, the block will work correctly. The frequencies are given in Hz.


        The block can also use time tags such as those generated by the UHD Source block to update its internal timestamp. In this case the timestamps in the file should use UNIX seconds, since the UHD timestamps also use UNIX seconds. When using UHD time tags, the t0 parameter can be left as 0.


        The Doppler correction block interpolates the frequency linearly between each pair of entries in the text file, and generates a correction with continuous phase.

        Constructor Specific Documentation:

        Build the Doppler Correction block.

        Args:
            filename : Path of the text file describing the Doppler data
            samp_rate : Sample rate
            t0 : Timestamp corresponding to the first sample
        """
        return _satellites_swig.doppler_correction_sptr_make(self, filename, samp_rate, t0)

    def history(self) -> "unsigned int":
        r"""history(doppler_correction_sptr self) -> unsigned int"""
        return _satellites_swig.doppler_correction_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(doppler_correction_sptr self) -> int"""
        return _satellites_swig.doppler_correction_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(doppler_correction_sptr self) -> double"""
        return _satellites_swig.doppler_correction_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(doppler_correction_sptr self) -> uint64_t"""
        return _satellites_swig.doppler_correction_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(doppler_correction_sptr self) -> uint64_t"""
        return _satellites_swig.doppler_correction_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(doppler_correction_sptr self) -> bool"""
        return _satellites_swig.doppler_correction_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(doppler_correction_sptr self) -> bool"""
        return _satellites_swig.doppler_correction_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(doppler_correction_sptr self) -> std::string"""
        return _satellites_swig.doppler_correction_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(doppler_correction_sptr self) -> int"""
        return _satellites_swig.doppler_correction_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(doppler_correction_sptr self)"""
        return _satellites_swig.doppler_correction_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(doppler_correction_sptr self) -> bool"""
        return _satellites_swig.doppler_correction_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(doppler_correction_sptr self) -> int"""
        return _satellites_swig.doppler_correction_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(doppler_correction_sptr self) -> float"""
        return _satellites_swig.doppler_correction_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(doppler_correction_sptr self)"""
        return _satellites_swig.doppler_correction_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(doppler_correction_sptr self) -> int"""
        return _satellites_swig.doppler_correction_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(doppler_correction_sptr self) -> int"""
        return _satellites_swig.doppler_correction_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(doppler_correction_sptr self) -> std::string"""
        return _satellites_swig.doppler_correction_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(doppler_correction_sptr self) -> std::string"""
        return _satellites_swig.doppler_correction_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(doppler_correction_sptr self) -> long"""
        return _satellites_swig.doppler_correction_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(doppler_correction_sptr self) -> basic_block_sptr"""
        return _satellites_swig.doppler_correction_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(doppler_correction_sptr self) -> std::string"""
        return _satellites_swig.doppler_correction_sptr_alias(self)

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

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

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

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

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

# Register doppler_correction_sptr in _satellites_swig:
_satellites_swig.doppler_correction_sptr_swigregister(doppler_correction_sptr)

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

class encode_rs(object):
    r"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::encode_rs.

    To avoid accidental use of raw pointers, satellites::encode_rs's constructor is in a private implementation class. satellites::encode_rs::make is the public interface for creating new instances.

    Args:
        dual_basis : 
        interleave : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::encode_rs.

        To avoid accidental use of raw pointers, satellites::encode_rs's constructor is in a private implementation class. satellites::encode_rs::make is the public interface for creating new instances.

        Args:
            dual_basis : 
            interleave : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::encode_rs.

        To avoid accidental use of raw pointers, satellites::encode_rs's constructor is in a private implementation class. satellites::encode_rs::make is the public interface for creating new instances.

        Args:
            dual_basis : 
            interleave : 
        """
        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 fixedlen_to_pdu(object):
    r"""
    Fixedlen to PDU.

    Constructor Specific Documentation:

    Make a Fixedlen to PDU block.

    Args:
        type : 
        syncword_tag : 
        packet_len : 
        pack : 
    """

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

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

    @staticmethod
    def make(type: "gr::blocks::pdu::vector_type", syncword_tag: "std::string const &", packet_len: "size_t", pack: "bool"=False) -> "gr::satellites::fixedlen_to_pdu::sptr":
        r"""
        make(gr::blocks::pdu::vector_type type, std::string const & syncword_tag, size_t packet_len, bool pack=False) -> fixedlen_to_pdu_sptr
        Fixedlen to PDU.

        Constructor Specific Documentation:

        Make a Fixedlen to PDU block.

        Args:
            type : 
            syncword_tag : 
            packet_len : 
            pack : 
        """
        return _satellites_swig.fixedlen_to_pdu_make(type, syncword_tag, packet_len, pack)
    __swig_destroy__ = _satellites_swig.delete_fixedlen_to_pdu

# Register fixedlen_to_pdu in _satellites_swig:
_satellites_swig.fixedlen_to_pdu_swigregister(fixedlen_to_pdu)
class fixedlen_to_pdu_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::fixedlen_to_pdu > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fixedlen_to_pdu_sptr self) -> fixedlen_to_pdu_sptr
        __init__(fixedlen_to_pdu_sptr self, fixedlen_to_pdu p) -> fixedlen_to_pdu_sptr
        """
        _satellites_swig.fixedlen_to_pdu_sptr_swiginit(self, _satellites_swig.new_fixedlen_to_pdu_sptr(*args))

    def __deref__(self) -> "gr::satellites::fixedlen_to_pdu *":
        r"""__deref__(fixedlen_to_pdu_sptr self) -> fixedlen_to_pdu"""
        return _satellites_swig.fixedlen_to_pdu_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_fixedlen_to_pdu_sptr

    def make(self, type: "gr::blocks::pdu::vector_type", syncword_tag: "std::string const &", packet_len: "size_t", pack: "bool"=False) -> "gr::satellites::fixedlen_to_pdu::sptr":
        r"""
        make(fixedlen_to_pdu_sptr self, gr::blocks::pdu::vector_type type, std::string const & syncword_tag, size_t packet_len, bool pack=False) -> fixedlen_to_pdu_sptr
        Fixedlen to PDU.

        Constructor Specific Documentation:

        Make a Fixedlen to PDU block.

        Args:
            type : 
            syncword_tag : 
            packet_len : 
            pack : 
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_make(self, type, syncword_tag, packet_len, pack)

    def history(self) -> "unsigned int":
        r"""history(fixedlen_to_pdu_sptr self) -> unsigned int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(fixedlen_to_pdu_sptr self) -> int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fixedlen_to_pdu_sptr self) -> double"""
        return _satellites_swig.fixedlen_to_pdu_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fixedlen_to_pdu_sptr self) -> uint64_t"""
        return _satellites_swig.fixedlen_to_pdu_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fixedlen_to_pdu_sptr self) -> uint64_t"""
        return _satellites_swig.fixedlen_to_pdu_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fixedlen_to_pdu_sptr self) -> bool"""
        return _satellites_swig.fixedlen_to_pdu_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fixedlen_to_pdu_sptr self) -> bool"""
        return _satellites_swig.fixedlen_to_pdu_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(fixedlen_to_pdu_sptr self) -> std::string"""
        return _satellites_swig.fixedlen_to_pdu_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fixedlen_to_pdu_sptr self) -> int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fixedlen_to_pdu_sptr self)"""
        return _satellites_swig.fixedlen_to_pdu_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fixedlen_to_pdu_sptr self) -> bool"""
        return _satellites_swig.fixedlen_to_pdu_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fixedlen_to_pdu_sptr self) -> int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fixedlen_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fixedlen_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_avg(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fixedlen_to_pdu_sptr self, int which) -> float
        pc_input_buffers_full_var(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fixedlen_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fixedlen_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_avg(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fixedlen_to_pdu_sptr self, int which) -> float
        pc_output_buffers_full_var(fixedlen_to_pdu_sptr self) -> pmt_vector_float
        """
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fixedlen_to_pdu_sptr self) -> float"""
        return _satellites_swig.fixedlen_to_pdu_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fixedlen_to_pdu_sptr self)"""
        return _satellites_swig.fixedlen_to_pdu_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fixedlen_to_pdu_sptr self) -> int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fixedlen_to_pdu_sptr self) -> int"""
        return _satellites_swig.fixedlen_to_pdu_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(fixedlen_to_pdu_sptr self) -> std::string"""
        return _satellites_swig.fixedlen_to_pdu_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fixedlen_to_pdu_sptr self) -> std::string"""
        return _satellites_swig.fixedlen_to_pdu_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(fixedlen_to_pdu_sptr self) -> long"""
        return _satellites_swig.fixedlen_to_pdu_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fixedlen_to_pdu_sptr self) -> basic_block_sptr"""
        return _satellites_swig.fixedlen_to_pdu_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(fixedlen_to_pdu_sptr self) -> std::string"""
        return _satellites_swig.fixedlen_to_pdu_sptr_alias(self)

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

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

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

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

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

# Register fixedlen_to_pdu_sptr in _satellites_swig:
_satellites_swig.fixedlen_to_pdu_sptr_swigregister(fixedlen_to_pdu_sptr)

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

class lilacsat1_demux(object):
    r"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::lilacsat1_demux.

    To avoid accidental use of raw pointers, satellits::lilacsat1_demux's constructor is in a private implementation class. satellites::lilacsat1_demux::make is the public interface for creating new instances.

    Args:
        tag : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::lilacsat1_demux.

        To avoid accidental use of raw pointers, satellits::lilacsat1_demux's constructor is in a private implementation class. satellites::lilacsat1_demux::make is the public interface for creating new instances.

        Args:
            tag : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::lilacsat1_demux.

        To avoid accidental use of raw pointers, satellits::lilacsat1_demux's constructor is in a private implementation class. satellites::lilacsat1_demux::make is the public interface for creating new instances.

        Args:
            tag : 
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::matrix_deinterleaver_soft.

    To avoid accidental use of raw pointers, satellites::matrix_deinterleaver_soft's constructor is in a private implementation class. satellites::matrix_deinterleaver_soft::make is the public interface for creating new instances.

    Args:
        rows : 
        cols : 
        output_size : 
        output_skip : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::matrix_deinterleaver_soft.

        To avoid accidental use of raw pointers, satellites::matrix_deinterleaver_soft's constructor is in a private implementation class. satellites::matrix_deinterleaver_soft::make is the public interface for creating new instances.

        Args:
            rows : 
            cols : 
            output_size : 
            output_skip : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::matrix_deinterleaver_soft.

        To avoid accidental use of raw pointers, satellites::matrix_deinterleaver_soft's constructor is in a private implementation class. satellites::matrix_deinterleaver_soft::make is the public interface for creating new instances.

        Args:
            rows : 
            cols : 
            output_size : 
            output_skip : 
        """
        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"""
    NRZI decode.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::nrzi_decode.

    To avoid accidental use of raw pointers, satellites::nrzi_decode's constructor is in a private implementation class. satellites::nrzi_decode::make is the public interface for creating new instances.
    """

    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
        NRZI decode.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nrzi_decode.

        To avoid accidental use of raw pointers, satellites::nrzi_decode's constructor is in a private implementation class. satellites::nrzi_decode::make is the public interface for creating new instances.
        """
        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)
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
        NRZI decode.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nrzi_decode.

        To avoid accidental use of raw pointers, satellites::nrzi_decode's constructor is in a private implementation class. satellites::nrzi_decode::make is the public interface for creating new instances.
        """
        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"""
    NRZI encode.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::nrzi_encode.

    To avoid accidental use of raw pointers, satellites::nrzi_encode's constructor is in a private implementation class. satellites::nrzi_encode::make is the public interface for creating new instances.
    """

    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
        NRZI encode.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nrzi_encode.

        To avoid accidental use of raw pointers, satellites::nrzi_encode's constructor is in a private implementation class. satellites::nrzi_encode::make is the public interface for creating new instances.
        """
        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)
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
        NRZI encode.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nrzi_encode.

        To avoid accidental use of raw pointers, satellites::nrzi_encode's constructor is in a private implementation class. satellites::nrzi_encode::make is the public interface for creating new instances.
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::nusat_decoder.

    To avoid accidental use of raw pointers, satellites::nusat_decoder's constructor is in a private implementation class. satellites::nusat_decoder::make is the public interface for creating new instances.
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nusat_decoder.

        To avoid accidental use of raw pointers, satellites::nusat_decoder's constructor is in a private implementation class. satellites::nusat_decoder::make is the public interface for creating new instances.
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::nusat_decoder.

        To avoid accidental use of raw pointers, satellites::nusat_decoder's constructor is in a private implementation class. satellites::nusat_decoder::make is the public interface for creating new instances.
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::pdu_add_meta.

    To avoid accidental use of raw pointers, satellites::pdu_add_meta's constructor is in a private implementation class. satellites::pdu_add_meta::make is the public interface for creating new instances.

    Args:
        meta : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_add_meta.

        To avoid accidental use of raw pointers, satellites::pdu_add_meta's constructor is in a private implementation class. satellites::pdu_add_meta::make is the public interface for creating new instances.

        Args:
            meta : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_add_meta.

        To avoid accidental use of raw pointers, satellites::pdu_add_meta's constructor is in a private implementation class. satellites::pdu_add_meta::make is the public interface for creating new instances.

        Args:
            meta : 
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::pdu_head_tail.

    To avoid accidental use of raw pointers, satellites::pdu_head_tail's constructor is in a private implementation class. satellites::pdu_head_tail::make is the public interface for creating new instances.

    Args:
        mode : 
        num : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_head_tail.

        To avoid accidental use of raw pointers, satellites::pdu_head_tail's constructor is in a private implementation class. satellites::pdu_head_tail::make is the public interface for creating new instances.

        Args:
            mode : 
            num : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_head_tail.

        To avoid accidental use of raw pointers, satellites::pdu_head_tail's constructor is in a private implementation class. satellites::pdu_head_tail::make is the public interface for creating new instances.

        Args:
            mode : 
            num : 
        """
        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"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::pdu_length_filter.

    To avoid accidental use of raw pointers, satellites::pdu_length_filter's constructor is in a private implementation class. satellites::pdu_length_filter::make is the public interface for creating new instances.

    Args:
        min : 
        max : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_length_filter.

        To avoid accidental use of raw pointers, satellites::pdu_length_filter's constructor is in a private implementation class. satellites::pdu_length_filter::make is the public interface for creating new instances.

        Args:
            min : 
            max : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::pdu_length_filter.

        To avoid accidental use of raw pointers, satellites::pdu_length_filter's constructor is in a private implementation class. satellites::pdu_length_filter::make is the public interface for creating new instances.

        Args:
            min : 
            max : 
        """
        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 pdu_scrambler(object):
    r"""
    PDU Scrambler.

    Uses a predefined sequence to implement a synchronous scrambler that acts on PDUs. The scrambling sequence needs to be longer than the PDUs that the block will process. PDUs which are longer than the sequence are dropped.

    Constructor Specific Documentation:

    Build the PDU Scrambler block.

    Args:
        sequence : The scrambling sequence to use.
    """

    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(sequence: "std::vector< uint8_t,std::allocator< uint8_t > > const &") -> "gr::satellites::pdu_scrambler::sptr":
        r"""
        make(std::vector< uint8_t,std::allocator< uint8_t > > const & sequence) -> pdu_scrambler_sptr
        PDU Scrambler.

        Uses a predefined sequence to implement a synchronous scrambler that acts on PDUs. The scrambling sequence needs to be longer than the PDUs that the block will process. PDUs which are longer than the sequence are dropped.

        Constructor Specific Documentation:

        Build the PDU Scrambler block.

        Args:
            sequence : The scrambling sequence to use.
        """
        return _satellites_swig.pdu_scrambler_make(sequence)
    __swig_destroy__ = _satellites_swig.delete_pdu_scrambler

# Register pdu_scrambler in _satellites_swig:
_satellites_swig.pdu_scrambler_swigregister(pdu_scrambler)
class pdu_scrambler_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::pdu_scrambler > 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_scrambler_sptr self) -> pdu_scrambler_sptr
        __init__(pdu_scrambler_sptr self, pdu_scrambler p) -> pdu_scrambler_sptr
        """
        _satellites_swig.pdu_scrambler_sptr_swiginit(self, _satellites_swig.new_pdu_scrambler_sptr(*args))

    def __deref__(self) -> "gr::satellites::pdu_scrambler *":
        r"""__deref__(pdu_scrambler_sptr self) -> pdu_scrambler"""
        return _satellites_swig.pdu_scrambler_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_pdu_scrambler_sptr

    def make(self, sequence: "std::vector< uint8_t,std::allocator< uint8_t > > const &") -> "gr::satellites::pdu_scrambler::sptr":
        r"""
        make(pdu_scrambler_sptr self, std::vector< uint8_t,std::allocator< uint8_t > > const & sequence) -> pdu_scrambler_sptr
        PDU Scrambler.

        Uses a predefined sequence to implement a synchronous scrambler that acts on PDUs. The scrambling sequence needs to be longer than the PDUs that the block will process. PDUs which are longer than the sequence are dropped.

        Constructor Specific Documentation:

        Build the PDU Scrambler block.

        Args:
            sequence : The scrambling sequence to use.
        """
        return _satellites_swig.pdu_scrambler_sptr_make(self, sequence)

    def history(self) -> "unsigned int":
        r"""history(pdu_scrambler_sptr self) -> unsigned int"""
        return _satellites_swig.pdu_scrambler_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_scrambler_sptr self) -> int"""
        return _satellites_swig.pdu_scrambler_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_scrambler_sptr self) -> double"""
        return _satellites_swig.pdu_scrambler_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_scrambler_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_scrambler_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_scrambler_sptr self) -> uint64_t"""
        return _satellites_swig.pdu_scrambler_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_scrambler_sptr self) -> bool"""
        return _satellites_swig.pdu_scrambler_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_scrambler_sptr self) -> bool"""
        return _satellites_swig.pdu_scrambler_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(pdu_scrambler_sptr self) -> std::string"""
        return _satellites_swig.pdu_scrambler_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_scrambler_sptr self) -> int"""
        return _satellites_swig.pdu_scrambler_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_scrambler_sptr self)"""
        return _satellites_swig.pdu_scrambler_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_scrambler_sptr self) -> bool"""
        return _satellites_swig.pdu_scrambler_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_scrambler_sptr self) -> int"""
        return _satellites_swig.pdu_scrambler_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_scrambler_sptr self) -> float"""
        return _satellites_swig.pdu_scrambler_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_scrambler_sptr self)"""
        return _satellites_swig.pdu_scrambler_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_scrambler_sptr self) -> int"""
        return _satellites_swig.pdu_scrambler_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_scrambler_sptr self) -> int"""
        return _satellites_swig.pdu_scrambler_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(pdu_scrambler_sptr self) -> std::string"""
        return _satellites_swig.pdu_scrambler_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_scrambler_sptr self) -> std::string"""
        return _satellites_swig.pdu_scrambler_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(pdu_scrambler_sptr self) -> long"""
        return _satellites_swig.pdu_scrambler_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_scrambler_sptr self) -> basic_block_sptr"""
        return _satellites_swig.pdu_scrambler_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(pdu_scrambler_sptr self) -> std::string"""
        return _satellites_swig.pdu_scrambler_sptr_alias(self)

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

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

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

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

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

# Register pdu_scrambler_sptr in _satellites_swig:
_satellites_swig.pdu_scrambler_sptr_swigregister(pdu_scrambler_sptr)

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

class phase_unwrap(object):
    r"""
    Unwraps a phase time series.

    The Phase Unwrap block unwraps a phase input by counting integer cycles. The integer number of cycles is given as an int64_t, so that overflows are impossible in most use cases. The output of the block is a vector of 12 bytes that contains the integer number of cycles in the first 8 bytes and the fractional phase in radians in the last 4 bytes.

    Constructor Specific Documentation:

    Build the Phase Unwrap block.
    """

    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::phase_unwrap::sptr":
        r"""
        make() -> phase_unwrap_sptr
        Unwraps a phase time series.

        The Phase Unwrap block unwraps a phase input by counting integer cycles. The integer number of cycles is given as an int64_t, so that overflows are impossible in most use cases. The output of the block is a vector of 12 bytes that contains the integer number of cycles in the first 8 bytes and the fractional phase in radians in the last 4 bytes.

        Constructor Specific Documentation:

        Build the Phase Unwrap block.
        """
        return _satellites_swig.phase_unwrap_make()
    __swig_destroy__ = _satellites_swig.delete_phase_unwrap

# Register phase_unwrap in _satellites_swig:
_satellites_swig.phase_unwrap_swigregister(phase_unwrap)
class phase_unwrap_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::satellites::phase_unwrap > 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__(phase_unwrap_sptr self) -> phase_unwrap_sptr
        __init__(phase_unwrap_sptr self, phase_unwrap p) -> phase_unwrap_sptr
        """
        _satellites_swig.phase_unwrap_sptr_swiginit(self, _satellites_swig.new_phase_unwrap_sptr(*args))

    def __deref__(self) -> "gr::satellites::phase_unwrap *":
        r"""__deref__(phase_unwrap_sptr self) -> phase_unwrap"""
        return _satellites_swig.phase_unwrap_sptr___deref__(self)
    __swig_destroy__ = _satellites_swig.delete_phase_unwrap_sptr

    def make(self) -> "gr::satellites::phase_unwrap::sptr":
        r"""
        make(phase_unwrap_sptr self) -> phase_unwrap_sptr
        Unwraps a phase time series.

        The Phase Unwrap block unwraps a phase input by counting integer cycles. The integer number of cycles is given as an int64_t, so that overflows are impossible in most use cases. The output of the block is a vector of 12 bytes that contains the integer number of cycles in the first 8 bytes and the fractional phase in radians in the last 4 bytes.

        Constructor Specific Documentation:

        Build the Phase Unwrap block.
        """
        return _satellites_swig.phase_unwrap_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(phase_unwrap_sptr self) -> unsigned int"""
        return _satellites_swig.phase_unwrap_sptr_history(self)

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

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

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

    def output_multiple(self) -> "int":
        r"""output_multiple(phase_unwrap_sptr self) -> int"""
        return _satellites_swig.phase_unwrap_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(phase_unwrap_sptr self) -> double"""
        return _satellites_swig.phase_unwrap_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(phase_unwrap_sptr self) -> uint64_t"""
        return _satellites_swig.phase_unwrap_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(phase_unwrap_sptr self) -> uint64_t"""
        return _satellites_swig.phase_unwrap_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(phase_unwrap_sptr self) -> bool"""
        return _satellites_swig.phase_unwrap_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(phase_unwrap_sptr self) -> bool"""
        return _satellites_swig.phase_unwrap_sptr_stop(self)

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

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

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

    def log_level(self) -> "std::string":
        r"""log_level(phase_unwrap_sptr self) -> std::string"""
        return _satellites_swig.phase_unwrap_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(phase_unwrap_sptr self) -> int"""
        return _satellites_swig.phase_unwrap_sptr_max_noutput_items(self)

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

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(phase_unwrap_sptr self)"""
        return _satellites_swig.phase_unwrap_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(phase_unwrap_sptr self) -> bool"""
        return _satellites_swig.phase_unwrap_sptr_is_set_max_noutput_items(self)

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

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(phase_unwrap_sptr self) -> int"""
        return _satellites_swig.phase_unwrap_sptr_min_noutput_items(self)

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

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

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

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

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(phase_unwrap_sptr self) -> float"""
        return _satellites_swig.phase_unwrap_sptr_pc_throughput_avg(self)

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

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(phase_unwrap_sptr self)"""
        return _satellites_swig.phase_unwrap_sptr_unset_processor_affinity(self)

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

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(phase_unwrap_sptr self) -> int"""
        return _satellites_swig.phase_unwrap_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(phase_unwrap_sptr self) -> int"""
        return _satellites_swig.phase_unwrap_sptr_thread_priority(self)

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

    def name(self) -> "std::string":
        r"""name(phase_unwrap_sptr self) -> std::string"""
        return _satellites_swig.phase_unwrap_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(phase_unwrap_sptr self) -> std::string"""
        return _satellites_swig.phase_unwrap_sptr_symbol_name(self)

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

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

    def unique_id(self) -> "long":
        r"""unique_id(phase_unwrap_sptr self) -> long"""
        return _satellites_swig.phase_unwrap_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(phase_unwrap_sptr self) -> basic_block_sptr"""
        return _satellites_swig.phase_unwrap_sptr_to_basic_block(self)

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

    def alias(self) -> "std::string":
        r"""alias(phase_unwrap_sptr self) -> std::string"""
        return _satellites_swig.phase_unwrap_sptr_alias(self)

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

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

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

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

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

# Register phase_unwrap_sptr in _satellites_swig:
_satellites_swig.phase_unwrap_sptr_swigregister(phase_unwrap_sptr)

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

class u482c_decode(object):
    r"""
    <+description of block+>

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::u482c_decode.

    To avoid accidental use of raw pointers, satellites::u482c_decode's constructor is in a private implementation class. satellites::u482c_decode::make is the public interface for creating new instances.

    Args:
        verbose : 
        viterbi : 
        scrambler : 
        rs : 
    """

    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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::u482c_decode.

        To avoid accidental use of raw pointers, satellites::u482c_decode's constructor is in a private implementation class. satellites::u482c_decode::make is the public interface for creating new instances.

        Args:
            verbose : 
            viterbi : 
            scrambler : 
            rs : 
        """
        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)
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
        <+description of block+>

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::u482c_decode.

        To avoid accidental use of raw pointers, satellites::u482c_decode's constructor is in a private implementation class. satellites::u482c_decode::make is the public interface for creating new instances.

        Args:
            verbose : 
            viterbi : 
            scrambler : 
            rs : 
        """
        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"""
    insert a packet length field into a tagged stream

    input: stream of bits (unpacked bytes) with packet_len tags output: a tagged stream of bits containing field length + packet bits


    This block prepends a packet length field into a tagged stream.

    Constructor Specific Documentation:



    Args:
        packet_key : tag key used to mark packets
        length_field_size : size of the packet length header
        endianness : header inserted msb or lsb
        use_golay : compute 24-bit golay header from 12-bit length
        sync_word : optional pre-header sync pattern
    """

    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
        insert a packet length field into a tagged stream

        input: stream of bits (unpacked bytes) with packet_len tags output: a tagged stream of bits containing field length + packet bits


        This block prepends a packet length field into a tagged stream.

        Constructor Specific Documentation:



        Args:
            packet_key : tag key used to mark packets
            length_field_size : size of the packet length header
            endianness : header inserted msb or lsb
            use_golay : compute 24-bit golay header from 12-bit length
            sync_word : optional pre-header sync pattern
        """
        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)
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
        insert a packet length field into a tagged stream

        input: stream of bits (unpacked bytes) with packet_len tags output: a tagged stream of bits containing field length + packet bits


        This block prepends a packet length field into a tagged stream.

        Constructor Specific Documentation:



        Args:
            packet_key : tag key used to mark packets
            length_field_size : size of the packet length header
            endianness : header inserted msb or lsb
            use_golay : compute 24-bit golay header from 12-bit length
            sync_word : optional pre-header sync pattern
        """
        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"""
    Examine input stream for sync tags and extract packet length.

    input: stream of bits (unpacked bytes) with sync tags output: a tagged stream of bits containing just the received packets


    This block uses the sync tag on the input stream to identify the header of packets. The length of each packet is extracted from the stream's header. The length of the header field and the endianness are parameters.

    Constructor Specific Documentation:



    Args:
        sync_key : 
        packet_key : 
        length_field_size : 
        max_packet_size : 
        endianness : 
        use_golay : For 24-bit golay headers
    """

    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
        Examine input stream for sync tags and extract packet length.

        input: stream of bits (unpacked bytes) with sync tags output: a tagged stream of bits containing just the received packets


        This block uses the sync tag on the input stream to identify the header of packets. The length of each packet is extracted from the stream's header. The length of the header field and the endianness are parameters.

        Constructor Specific Documentation:



        Args:
            sync_key : 
            packet_key : 
            length_field_size : 
            max_packet_size : 
            endianness : 
            use_golay : For 24-bit golay headers
        """
        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)
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
        Examine input stream for sync tags and extract packet length.

        input: stream of bits (unpacked bytes) with sync tags output: a tagged stream of bits containing just the received packets


        This block uses the sync tag on the input stream to identify the header of packets. The length of each packet is extracted from the stream's header. The length of the header field and the endianness are parameters.

        Constructor Specific Documentation:



        Args:
            sync_key : 
            packet_key : 
            length_field_size : 
            max_packet_size : 
            endianness : 
            use_golay : For 24-bit golay headers
        """
        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"""
    Viterbi decoder.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of satellites::viterbi_decoder.

    To avoid accidental use of raw pointers, satellites::viterbi_decoder's constructor is in a private implementation class. satellites::viterbi_decoder::make is the public interface for creating new instances.

    Args:
        constraint : 
        polynomials : 
    """

    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
        Viterbi decoder.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::viterbi_decoder.

        To avoid accidental use of raw pointers, satellites::viterbi_decoder's constructor is in a private implementation class. satellites::viterbi_decoder::make is the public interface for creating new instances.

        Args:
            constraint : 
            polynomials : 
        """
        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)
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
        Viterbi decoder.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of satellites::viterbi_decoder.

        To avoid accidental use of raw pointers, satellites::viterbi_decoder's constructor is in a private implementation class. satellites::viterbi_decoder::make is the public interface for creating new instances.

        Args:
            constraint : 
            polynomials : 
        """
        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;


