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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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



def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _digital_swig1.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 _digital_swig1.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 _digital_swig1.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 _digital_swig1.high_res_timer_epoch()
class control_loop(object):
    r"""Proxy of C++ gr::blocks::control_loop 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__(control_loop self) -> control_loop
        __init__(control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        _digital_swig1.control_loop_swiginit(self, _digital_swig1.new_control_loop(*args))
    __swig_destroy__ = _digital_swig1.delete_control_loop

    def update_gains(self) -> "void":
        r"""update_gains(control_loop self)"""
        return _digital_swig1.control_loop_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(control_loop self, float error)"""
        return _digital_swig1.control_loop_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(control_loop self)"""
        return _digital_swig1.control_loop_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(control_loop self)"""
        return _digital_swig1.control_loop_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(control_loop self, float bw)"""
        return _digital_swig1.control_loop_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(control_loop self, float df)"""
        return _digital_swig1.control_loop_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(control_loop self, float alpha)"""
        return _digital_swig1.control_loop_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(control_loop self, float beta)"""
        return _digital_swig1.control_loop_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(control_loop self, float phase)"""
        return _digital_swig1.control_loop_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(control_loop self) -> float"""
        return _digital_swig1.control_loop_get_min_freq(self)

# Register control_loop in _digital_swig1:
_digital_swig1.control_loop_swigregister(control_loop)


def tanhf_lut(x: "float") -> "float":
    r"""tanhf_lut(float x) -> float"""
    return _digital_swig1.tanhf_lut(x)
class additive_scrambler_bb(object):
    r"""Proxy of C++ gr::digital::additive_scrambler_bb class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::additive_scrambler_bb::sptr":
        r"""make(int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key="") -> additive_scrambler_bb_sptr"""
        return _digital_swig1.additive_scrambler_bb_make(*args, **kwargs)

    def mask(self) -> "int":
        r"""mask(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_mask(self)

    def seed(self) -> "int":
        r"""seed(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_seed(self)

    def len(self) -> "int":
        r"""len(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_len(self)

    def count(self) -> "int":
        r"""count(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_count(self)

    def bits_per_byte(self) -> "int":
        r"""bits_per_byte(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_bits_per_byte(self)
    __swig_destroy__ = _digital_swig1.delete_additive_scrambler_bb

# Register additive_scrambler_bb in _digital_swig1:
_digital_swig1.additive_scrambler_bb_swigregister(additive_scrambler_bb)
cvar = _digital_swig1.cvar

def additive_scrambler_bb_make(*args, **kwargs) -> "gr::digital::additive_scrambler_bb::sptr":
    r"""additive_scrambler_bb_make(int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key="") -> additive_scrambler_bb_sptr"""
    return _digital_swig1.additive_scrambler_bb_make(*args, **kwargs)

class clock_recovery_mm_cc(object):
    r"""Proxy of C++ gr::digital::clock_recovery_mm_cc class."""

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

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

    @staticmethod
    def make(omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_cc::sptr":
        r"""make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

    def mu(self) -> "float":
        r"""mu(clock_recovery_mm_cc self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_mu(self)

    def omega(self) -> "float":
        r"""omega(clock_recovery_mm_cc self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_omega(self)

    def gain_mu(self) -> "float":
        r"""gain_mu(clock_recovery_mm_cc self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_gain_mu(self)

    def gain_omega(self) -> "float":
        r"""gain_omega(clock_recovery_mm_cc self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_gain_omega(self)

    def set_verbose(self, verbose: "bool") -> "void":
        r"""set_verbose(clock_recovery_mm_cc self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_cc_set_verbose(self, verbose)

    def set_gain_mu(self, gain_mu: "float") -> "void":
        r"""set_gain_mu(clock_recovery_mm_cc self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_cc_set_gain_mu(self, gain_mu)

    def set_gain_omega(self, gain_omega: "float") -> "void":
        r"""set_gain_omega(clock_recovery_mm_cc self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_cc_set_gain_omega(self, gain_omega)

    def set_mu(self, mu: "float") -> "void":
        r"""set_mu(clock_recovery_mm_cc self, float mu)"""
        return _digital_swig1.clock_recovery_mm_cc_set_mu(self, mu)

    def set_omega(self, omega: "float") -> "void":
        r"""set_omega(clock_recovery_mm_cc self, float omega)"""
        return _digital_swig1.clock_recovery_mm_cc_set_omega(self, omega)
    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_cc

# Register clock_recovery_mm_cc in _digital_swig1:
_digital_swig1.clock_recovery_mm_cc_swigregister(clock_recovery_mm_cc)

def clock_recovery_mm_cc_make(omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_cc::sptr":
    r"""clock_recovery_mm_cc_make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
    return _digital_swig1.clock_recovery_mm_cc_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

class clock_recovery_mm_ff(object):
    r"""Proxy of C++ gr::digital::clock_recovery_mm_ff class."""

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

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

    @staticmethod
    def make(omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_ff::sptr":
        r"""make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

    def mu(self) -> "float":
        r"""mu(clock_recovery_mm_ff self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_mu(self)

    def omega(self) -> "float":
        r"""omega(clock_recovery_mm_ff self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_omega(self)

    def gain_mu(self) -> "float":
        r"""gain_mu(clock_recovery_mm_ff self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_gain_mu(self)

    def gain_omega(self) -> "float":
        r"""gain_omega(clock_recovery_mm_ff self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_gain_omega(self)

    def set_verbose(self, verbose: "bool") -> "void":
        r"""set_verbose(clock_recovery_mm_ff self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_ff_set_verbose(self, verbose)

    def set_gain_mu(self, gain_mu: "float") -> "void":
        r"""set_gain_mu(clock_recovery_mm_ff self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_ff_set_gain_mu(self, gain_mu)

    def set_gain_omega(self, gain_omega: "float") -> "void":
        r"""set_gain_omega(clock_recovery_mm_ff self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_ff_set_gain_omega(self, gain_omega)

    def set_mu(self, mu: "float") -> "void":
        r"""set_mu(clock_recovery_mm_ff self, float mu)"""
        return _digital_swig1.clock_recovery_mm_ff_set_mu(self, mu)

    def set_omega(self, omega: "float") -> "void":
        r"""set_omega(clock_recovery_mm_ff self, float omega)"""
        return _digital_swig1.clock_recovery_mm_ff_set_omega(self, omega)
    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_ff

# Register clock_recovery_mm_ff in _digital_swig1:
_digital_swig1.clock_recovery_mm_ff_swigregister(clock_recovery_mm_ff)

def clock_recovery_mm_ff_make(omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_ff::sptr":
    r"""clock_recovery_mm_ff_make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
    return _digital_swig1.clock_recovery_mm_ff_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

class diff_decoder_bb(object):
    r"""Proxy of C++ gr::digital::diff_decoder_bb class."""

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

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

    @staticmethod
    def make(modulus: "unsigned int") -> "gr::digital::diff_decoder_bb::sptr":
        r"""make(unsigned int modulus) -> diff_decoder_bb_sptr"""
        return _digital_swig1.diff_decoder_bb_make(modulus)
    __swig_destroy__ = _digital_swig1.delete_diff_decoder_bb

# Register diff_decoder_bb in _digital_swig1:
_digital_swig1.diff_decoder_bb_swigregister(diff_decoder_bb)

def diff_decoder_bb_make(modulus: "unsigned int") -> "gr::digital::diff_decoder_bb::sptr":
    r"""diff_decoder_bb_make(unsigned int modulus) -> diff_decoder_bb_sptr"""
    return _digital_swig1.diff_decoder_bb_make(modulus)

class diff_encoder_bb(object):
    r"""Proxy of C++ gr::digital::diff_encoder_bb class."""

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

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

    @staticmethod
    def make(modulus: "unsigned int") -> "gr::digital::diff_encoder_bb::sptr":
        r"""make(unsigned int modulus) -> diff_encoder_bb_sptr"""
        return _digital_swig1.diff_encoder_bb_make(modulus)
    __swig_destroy__ = _digital_swig1.delete_diff_encoder_bb

# Register diff_encoder_bb in _digital_swig1:
_digital_swig1.diff_encoder_bb_swigregister(diff_encoder_bb)

def diff_encoder_bb_make(modulus: "unsigned int") -> "gr::digital::diff_encoder_bb::sptr":
    r"""diff_encoder_bb_make(unsigned int modulus) -> diff_encoder_bb_sptr"""
    return _digital_swig1.diff_encoder_bb_make(modulus)

class diff_phasor_cc(object):
    r"""Proxy of C++ gr::digital::diff_phasor_cc class."""

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

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

    @staticmethod
    def make() -> "gr::digital::diff_phasor_cc::sptr":
        r"""make() -> diff_phasor_cc_sptr"""
        return _digital_swig1.diff_phasor_cc_make()
    __swig_destroy__ = _digital_swig1.delete_diff_phasor_cc

# Register diff_phasor_cc in _digital_swig1:
_digital_swig1.diff_phasor_cc_swigregister(diff_phasor_cc)

def diff_phasor_cc_make() -> "gr::digital::diff_phasor_cc::sptr":
    r"""diff_phasor_cc_make() -> diff_phasor_cc_sptr"""
    return _digital_swig1.diff_phasor_cc_make()

class fll_band_edge_cc(control_loop):
    r"""Proxy of C++ gr::digital::fll_band_edge_cc class."""

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

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

    @staticmethod
    def make(samps_per_sym: "float", rolloff: "float", filter_size: "int", bandwidth: "float") -> "gr::digital::fll_band_edge_cc::sptr":
        r"""make(float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
        return _digital_swig1.fll_band_edge_cc_make(samps_per_sym, rolloff, filter_size, bandwidth)

    def set_samples_per_symbol(self, sps: "float") -> "void":
        r"""set_samples_per_symbol(fll_band_edge_cc self, float sps)"""
        return _digital_swig1.fll_band_edge_cc_set_samples_per_symbol(self, sps)

    def set_rolloff(self, rolloff: "float") -> "void":
        r"""set_rolloff(fll_band_edge_cc self, float rolloff)"""
        return _digital_swig1.fll_band_edge_cc_set_rolloff(self, rolloff)

    def set_filter_size(self, filter_size: "int") -> "void":
        r"""set_filter_size(fll_band_edge_cc self, int filter_size)"""
        return _digital_swig1.fll_band_edge_cc_set_filter_size(self, filter_size)

    def samples_per_symbol(self) -> "float":
        r"""samples_per_symbol(fll_band_edge_cc self) -> float"""
        return _digital_swig1.fll_band_edge_cc_samples_per_symbol(self)

    def rolloff(self) -> "float":
        r"""rolloff(fll_band_edge_cc self) -> float"""
        return _digital_swig1.fll_band_edge_cc_rolloff(self)

    def filter_size(self) -> "int":
        r"""filter_size(fll_band_edge_cc self) -> int"""
        return _digital_swig1.fll_band_edge_cc_filter_size(self)

    def print_taps(self) -> "void":
        r"""print_taps(fll_band_edge_cc self)"""
        return _digital_swig1.fll_band_edge_cc_print_taps(self)
    __swig_destroy__ = _digital_swig1.delete_fll_band_edge_cc

# Register fll_band_edge_cc in _digital_swig1:
_digital_swig1.fll_band_edge_cc_swigregister(fll_band_edge_cc)

def fll_band_edge_cc_make(samps_per_sym: "float", rolloff: "float", filter_size: "int", bandwidth: "float") -> "gr::digital::fll_band_edge_cc::sptr":
    r"""fll_band_edge_cc_make(float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
    return _digital_swig1.fll_band_edge_cc_make(samps_per_sym, rolloff, filter_size, bandwidth)

class framer_sink_1(object):
    r"""Proxy of C++ gr::digital::framer_sink_1 class."""

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

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

    @staticmethod
    def make(target_queue: "msg_queue_sptr") -> "gr::digital::framer_sink_1::sptr":
        r"""make(msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
        return _digital_swig1.framer_sink_1_make(target_queue)
    __swig_destroy__ = _digital_swig1.delete_framer_sink_1

# Register framer_sink_1 in _digital_swig1:
_digital_swig1.framer_sink_1_swigregister(framer_sink_1)

def framer_sink_1_make(target_queue: "msg_queue_sptr") -> "gr::digital::framer_sink_1::sptr":
    r"""framer_sink_1_make(msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
    return _digital_swig1.framer_sink_1_make(target_queue)

class glfsr(object):
    r"""Proxy of C++ gr::digital::glfsr 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, mask: "uint32_t", seed: "uint32_t"):
        r"""__init__(glfsr self, uint32_t mask, uint32_t seed) -> glfsr"""
        _digital_swig1.glfsr_swiginit(self, _digital_swig1.new_glfsr(mask, seed))
    __swig_destroy__ = _digital_swig1.delete_glfsr

    @staticmethod
    def glfsr_mask(degree: "unsigned int") -> "uint32_t":
        r"""glfsr_mask(unsigned int degree) -> uint32_t"""
        return _digital_swig1.glfsr_glfsr_mask(degree)

    def next_bit(self) -> "uint8_t":
        r"""next_bit(glfsr self) -> uint8_t"""
        return _digital_swig1.glfsr_next_bit(self)

    def mask(self) -> "uint32_t":
        r"""mask(glfsr self) -> uint32_t"""
        return _digital_swig1.glfsr_mask(self)

# Register glfsr in _digital_swig1:
_digital_swig1.glfsr_swigregister(glfsr)

def glfsr_glfsr_mask(degree: "unsigned int") -> "uint32_t":
    r"""glfsr_glfsr_mask(unsigned int degree) -> uint32_t"""
    return _digital_swig1.glfsr_glfsr_mask(degree)

class glfsr_source_b(object):
    r"""Proxy of C++ gr::digital::glfsr_source_b class."""

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

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

    @staticmethod
    def make(degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=0x1) -> "gr::digital::glfsr_source_b::sptr":
        r"""make(unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=0x1) -> glfsr_source_b_sptr"""
        return _digital_swig1.glfsr_source_b_make(degree, repeat, mask, seed)

    def period(self) -> "uint32_t":
        r"""period(glfsr_source_b self) -> uint32_t"""
        return _digital_swig1.glfsr_source_b_period(self)

    def mask(self) -> "uint32_t":
        r"""mask(glfsr_source_b self) -> uint32_t"""
        return _digital_swig1.glfsr_source_b_mask(self)
    __swig_destroy__ = _digital_swig1.delete_glfsr_source_b

# Register glfsr_source_b in _digital_swig1:
_digital_swig1.glfsr_source_b_swigregister(glfsr_source_b)

def glfsr_source_b_make(degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=0x1) -> "gr::digital::glfsr_source_b::sptr":
    r"""glfsr_source_b_make(unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=0x1) -> glfsr_source_b_sptr"""
    return _digital_swig1.glfsr_source_b_make(degree, repeat, mask, seed)

class glfsr_source_f(object):
    r"""Proxy of C++ gr::digital::glfsr_source_f class."""

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

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

    @staticmethod
    def make(degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=1) -> "gr::digital::glfsr_source_f::sptr":
        r"""make(unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=1) -> glfsr_source_f_sptr"""
        return _digital_swig1.glfsr_source_f_make(degree, repeat, mask, seed)

    def period(self) -> "uint32_t":
        r"""period(glfsr_source_f self) -> uint32_t"""
        return _digital_swig1.glfsr_source_f_period(self)

    def mask(self) -> "uint32_t":
        r"""mask(glfsr_source_f self) -> uint32_t"""
        return _digital_swig1.glfsr_source_f_mask(self)
    __swig_destroy__ = _digital_swig1.delete_glfsr_source_f

# Register glfsr_source_f in _digital_swig1:
_digital_swig1.glfsr_source_f_swigregister(glfsr_source_f)

def glfsr_source_f_make(degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=1) -> "gr::digital::glfsr_source_f::sptr":
    r"""glfsr_source_f_make(unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=1) -> glfsr_source_f_sptr"""
    return _digital_swig1.glfsr_source_f_make(degree, repeat, mask, seed)

class hdlc_deframer_bp(object):
    r"""Proxy of C++ gr::digital::hdlc_deframer_bp class."""

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

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

    @staticmethod
    def make(length_min: "int", length_max: "int") -> "gr::digital::hdlc_deframer_bp::sptr":
        r"""make(int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
        return _digital_swig1.hdlc_deframer_bp_make(length_min, length_max)
    __swig_destroy__ = _digital_swig1.delete_hdlc_deframer_bp

# Register hdlc_deframer_bp in _digital_swig1:
_digital_swig1.hdlc_deframer_bp_swigregister(hdlc_deframer_bp)

def hdlc_deframer_bp_make(length_min: "int", length_max: "int") -> "gr::digital::hdlc_deframer_bp::sptr":
    r"""hdlc_deframer_bp_make(int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
    return _digital_swig1.hdlc_deframer_bp_make(length_min, length_max)

class hdlc_framer_pb(object):
    r"""Proxy of C++ gr::digital::hdlc_framer_pb class."""

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

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

    @staticmethod
    def make(frame_tag_name: "std::string const") -> "gr::digital::hdlc_framer_pb::sptr":
        r"""make(std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
        return _digital_swig1.hdlc_framer_pb_make(frame_tag_name)
    __swig_destroy__ = _digital_swig1.delete_hdlc_framer_pb

# Register hdlc_framer_pb in _digital_swig1:
_digital_swig1.hdlc_framer_pb_swigregister(hdlc_framer_pb)

def hdlc_framer_pb_make(frame_tag_name: "std::string const") -> "gr::digital::hdlc_framer_pb::sptr":
    r"""hdlc_framer_pb_make(std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
    return _digital_swig1.hdlc_framer_pb_make(frame_tag_name)

class header_payload_demux(object):
    r"""Proxy of C++ gr::digital::header_payload_demux class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::header_payload_demux::sptr":
        r"""make(int const header_len, int const items_per_symbol=1, int const guard_interval=0, std::string const & length_tag_key="frame_len", std::string const & trigger_tag_key="", bool const output_symbols=False, size_t const itemsize=sizeof(gr_complex), std::string const & timing_tag_key="", double const samp_rate=1.0, std::vector< std::string,std::allocator< std::string > > const & special_tags=std::vector< std::string >(), size_t const header_padding=0) -> header_payload_demux_sptr"""
        return _digital_swig1.header_payload_demux_make(*args, **kwargs)
    __swig_destroy__ = _digital_swig1.delete_header_payload_demux

# Register header_payload_demux in _digital_swig1:
_digital_swig1.header_payload_demux_swigregister(header_payload_demux)

def header_payload_demux_make(*args, **kwargs) -> "gr::digital::header_payload_demux::sptr":
    r"""header_payload_demux_make(int const header_len, int const items_per_symbol=1, int const guard_interval=0, std::string const & length_tag_key="frame_len", std::string const & trigger_tag_key="", bool const output_symbols=False, size_t const itemsize=sizeof(gr_complex), std::string const & timing_tag_key="", double const samp_rate=1.0, std::vector< std::string,std::allocator< std::string > > const & special_tags=std::vector< std::string >(), size_t const header_padding=0) -> header_payload_demux_sptr"""
    return _digital_swig1.header_payload_demux_make(*args, **kwargs)

class kurtotic_equalizer_cc(object):
    r"""Proxy of C++ gr::digital::kurtotic_equalizer_cc class."""

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

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

    @staticmethod
    def make(num_taps: "int", mu: "float") -> "gr::digital::kurtotic_equalizer_cc::sptr":
        r"""make(int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_make(num_taps, mu)

    def gain(self) -> "float":
        r"""gain(kurtotic_equalizer_cc self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(kurtotic_equalizer_cc self, float mu)"""
        return _digital_swig1.kurtotic_equalizer_cc_set_gain(self, mu)
    __swig_destroy__ = _digital_swig1.delete_kurtotic_equalizer_cc

# Register kurtotic_equalizer_cc in _digital_swig1:
_digital_swig1.kurtotic_equalizer_cc_swigregister(kurtotic_equalizer_cc)

def kurtotic_equalizer_cc_make(num_taps: "int", mu: "float") -> "gr::digital::kurtotic_equalizer_cc::sptr":
    r"""kurtotic_equalizer_cc_make(int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
    return _digital_swig1.kurtotic_equalizer_cc_make(num_taps, mu)

class lfsr(object):
    r"""Proxy of C++ gr::digital::lfsr 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, mask: "uint32_t", seed: "uint32_t", reg_len: "uint32_t"):
        r"""__init__(lfsr self, uint32_t mask, uint32_t seed, uint32_t reg_len) -> lfsr"""
        _digital_swig1.lfsr_swiginit(self, _digital_swig1.new_lfsr(mask, seed, reg_len))

    def next_bit(self) -> "unsigned char":
        r"""next_bit(lfsr self) -> unsigned char"""
        return _digital_swig1.lfsr_next_bit(self)

    def next_bit_scramble(self, input: "unsigned char") -> "unsigned char":
        r"""next_bit_scramble(lfsr self, unsigned char input) -> unsigned char"""
        return _digital_swig1.lfsr_next_bit_scramble(self, input)

    def next_bit_descramble(self, input: "unsigned char") -> "unsigned char":
        r"""next_bit_descramble(lfsr self, unsigned char input) -> unsigned char"""
        return _digital_swig1.lfsr_next_bit_descramble(self, input)

    def reset(self) -> "void":
        r"""reset(lfsr self)"""
        return _digital_swig1.lfsr_reset(self)

    def pre_shift(self, num: "int") -> "void":
        r"""pre_shift(lfsr self, int num)"""
        return _digital_swig1.lfsr_pre_shift(self, num)

    def mask(self) -> "int":
        r"""mask(lfsr self) -> int"""
        return _digital_swig1.lfsr_mask(self)
    __swig_destroy__ = _digital_swig1.delete_lfsr

# Register lfsr in _digital_swig1:
_digital_swig1.lfsr_swigregister(lfsr)

class map_bb(object):
    r"""Proxy of C++ gr::digital::map_bb class."""

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

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

    @staticmethod
    def make(map: "std::vector< int,std::allocator< int > > const &") -> "gr::digital::map_bb::sptr":
        r"""make(std::vector< int,std::allocator< int > > const & map) -> map_bb_sptr"""
        return _digital_swig1.map_bb_make(map)

    def set_map(self, map: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_map(map_bb self, std::vector< int,std::allocator< int > > const & map)"""
        return _digital_swig1.map_bb_set_map(self, map)

    def map(self) -> "std::vector< int,std::allocator< int > >":
        r"""map(map_bb self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.map_bb_map(self)
    __swig_destroy__ = _digital_swig1.delete_map_bb

# Register map_bb in _digital_swig1:
_digital_swig1.map_bb_swigregister(map_bb)

def map_bb_make(map: "std::vector< int,std::allocator< int > > const &") -> "gr::digital::map_bb::sptr":
    r"""map_bb_make(std::vector< int,std::allocator< int > > const & map) -> map_bb_sptr"""
    return _digital_swig1.map_bb_make(map)

TRELLIS_EUCLIDEAN = _digital_swig1.TRELLIS_EUCLIDEAN

TRELLIS_HARD_SYMBOL = _digital_swig1.TRELLIS_HARD_SYMBOL

TRELLIS_HARD_BIT = _digital_swig1.TRELLIS_HARD_BIT


def modulate_vector_bc(modulator: "basic_block_sptr", data: "std::vector< uint8_t,std::allocator< uint8_t > >", taps: "pmt_vector_float") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
    r"""modulate_vector_bc(basic_block_sptr modulator, std::vector< uint8_t,std::allocator< uint8_t > > data, pmt_vector_float taps) -> pmt_vector_cfloat"""
    return _digital_swig1.modulate_vector_bc(modulator, data, taps)
class msk_timing_recovery_cc(object):
    r"""Proxy of C++ gr::digital::msk_timing_recovery_cc class."""

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

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

    @staticmethod
    def make(sps: "float", gain: "float", limit: "float", osps: "int") -> "gr::digital::msk_timing_recovery_cc::sptr":
        r"""make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_make(sps, gain, limit, osps)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(msk_timing_recovery_cc self, float gain)"""
        return _digital_swig1.msk_timing_recovery_cc_set_gain(self, gain)

    def get_gain(self) -> "float":
        r"""get_gain(msk_timing_recovery_cc self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_get_gain(self)

    def set_limit(self, limit: "float") -> "void":
        r"""set_limit(msk_timing_recovery_cc self, float limit)"""
        return _digital_swig1.msk_timing_recovery_cc_set_limit(self, limit)

    def get_limit(self) -> "float":
        r"""get_limit(msk_timing_recovery_cc self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_get_limit(self)

    def set_sps(self, sps: "float") -> "void":
        r"""set_sps(msk_timing_recovery_cc self, float sps)"""
        return _digital_swig1.msk_timing_recovery_cc_set_sps(self, sps)

    def get_sps(self) -> "float":
        r"""get_sps(msk_timing_recovery_cc self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_get_sps(self)
    __swig_destroy__ = _digital_swig1.delete_msk_timing_recovery_cc

# Register msk_timing_recovery_cc in _digital_swig1:
_digital_swig1.msk_timing_recovery_cc_swigregister(msk_timing_recovery_cc)

def msk_timing_recovery_cc_make(sps: "float", gain: "float", limit: "float", osps: "int") -> "gr::digital::msk_timing_recovery_cc::sptr":
    r"""msk_timing_recovery_cc_make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
    return _digital_swig1.msk_timing_recovery_cc_make(sps, gain, limit, osps)

class additive_scrambler_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::additive_scrambler_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(additive_scrambler_bb_sptr self) -> additive_scrambler_bb_sptr
        __init__(additive_scrambler_bb_sptr self, additive_scrambler_bb p) -> additive_scrambler_bb_sptr
        """
        _digital_swig1.additive_scrambler_bb_sptr_swiginit(self, _digital_swig1.new_additive_scrambler_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::additive_scrambler_bb *":
        r"""__deref__(additive_scrambler_bb_sptr self) -> additive_scrambler_bb"""
        return _digital_swig1.additive_scrambler_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_additive_scrambler_bb_sptr

    def make(self, *args, **kwargs) -> "gr::digital::additive_scrambler_bb::sptr":
        r"""make(additive_scrambler_bb_sptr self, int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key="") -> additive_scrambler_bb_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_make(self, *args, **kwargs)

    def mask(self) -> "int":
        r"""mask(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_mask(self)

    def seed(self) -> "int":
        r"""seed(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_seed(self)

    def len(self) -> "int":
        r"""len(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_len(self)

    def count(self) -> "int":
        r"""count(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_count(self)

    def bits_per_byte(self) -> "int":
        r"""bits_per_byte(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_bits_per_byte(self)

    def history(self) -> "unsigned int":
        r"""history(additive_scrambler_bb_sptr self) -> unsigned int"""
        return _digital_swig1.additive_scrambler_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(additive_scrambler_bb_sptr self, int which, int delay)
        declare_sample_delay(additive_scrambler_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.additive_scrambler_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(additive_scrambler_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.additive_scrambler_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(additive_scrambler_bb_sptr self, int multiple)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(additive_scrambler_bb_sptr self) -> double"""
        return _digital_swig1.additive_scrambler_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(additive_scrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig1.additive_scrambler_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(additive_scrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig1.additive_scrambler_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(additive_scrambler_bb_sptr self) -> bool"""
        return _digital_swig1.additive_scrambler_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(additive_scrambler_bb_sptr self) -> bool"""
        return _digital_swig1.additive_scrambler_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(additive_scrambler_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.additive_scrambler_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(additive_scrambler_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.additive_scrambler_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(additive_scrambler_bb_sptr self, std::string level)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(additive_scrambler_bb_sptr self) -> std::string"""
        return _digital_swig1.additive_scrambler_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(additive_scrambler_bb_sptr self)"""
        return _digital_swig1.additive_scrambler_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(additive_scrambler_bb_sptr self) -> bool"""
        return _digital_swig1.additive_scrambler_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(additive_scrambler_bb_sptr self, int i) -> long"""
        return _digital_swig1.additive_scrambler_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(additive_scrambler_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(additive_scrambler_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.additive_scrambler_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(additive_scrambler_bb_sptr self, int i) -> long"""
        return _digital_swig1.additive_scrambler_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(additive_scrambler_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(additive_scrambler_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.additive_scrambler_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.additive_scrambler_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(additive_scrambler_bb_sptr self) -> float"""
        return _digital_swig1.additive_scrambler_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(additive_scrambler_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(additive_scrambler_bb_sptr self)"""
        return _digital_swig1.additive_scrambler_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(additive_scrambler_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.additive_scrambler_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(additive_scrambler_bb_sptr self) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(additive_scrambler_bb_sptr self, int priority) -> int"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(additive_scrambler_bb_sptr self) -> std::string"""
        return _digital_swig1.additive_scrambler_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(additive_scrambler_bb_sptr self) -> std::string"""
        return _digital_swig1.additive_scrambler_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(additive_scrambler_bb_sptr self) -> long"""
        return _digital_swig1.additive_scrambler_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(additive_scrambler_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(additive_scrambler_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.additive_scrambler_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(additive_scrambler_bb_sptr self) -> std::string"""
        return _digital_swig1.additive_scrambler_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(additive_scrambler_bb_sptr self, std::string name)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(additive_scrambler_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.additive_scrambler_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(additive_scrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(additive_scrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(additive_scrambler_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_subscribers(self, which_port)

# Register additive_scrambler_bb_sptr in _digital_swig1:
_digital_swig1.additive_scrambler_bb_sptr_swigregister(additive_scrambler_bb_sptr)


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

class burst_shaper_cc(object):
    r"""Proxy of C++ gr::digital::burst_shaper< gr_complex > class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::burst_shaper< std::complex< float > >::sptr":
        r"""make(pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_cc_sptr"""
        return _digital_swig1.burst_shaper_cc_make(*args, **kwargs)

    def pre_padding(self) -> "int":
        r"""pre_padding(burst_shaper_cc self) -> int"""
        return _digital_swig1.burst_shaper_cc_pre_padding(self)

    def post_padding(self) -> "int":
        r"""post_padding(burst_shaper_cc self) -> int"""
        return _digital_swig1.burst_shaper_cc_post_padding(self)

    def prefix_length(self) -> "int":
        r"""prefix_length(burst_shaper_cc self) -> int"""
        return _digital_swig1.burst_shaper_cc_prefix_length(self)

    def suffix_length(self) -> "int":
        r"""suffix_length(burst_shaper_cc self) -> int"""
        return _digital_swig1.burst_shaper_cc_suffix_length(self)
    __swig_destroy__ = _digital_swig1.delete_burst_shaper_cc

# Register burst_shaper_cc in _digital_swig1:
_digital_swig1.burst_shaper_cc_swigregister(burst_shaper_cc)

def burst_shaper_cc_make(*args, **kwargs) -> "gr::digital::burst_shaper< std::complex< float > >::sptr":
    r"""burst_shaper_cc_make(pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_cc_sptr"""
    return _digital_swig1.burst_shaper_cc_make(*args, **kwargs)

class burst_shaper_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::burst_shaper< gr_complex > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(burst_shaper_cc_sptr self) -> burst_shaper_cc_sptr
        __init__(burst_shaper_cc_sptr self, burst_shaper_cc p) -> burst_shaper_cc_sptr
        """
        _digital_swig1.burst_shaper_cc_sptr_swiginit(self, _digital_swig1.new_burst_shaper_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::burst_shaper< gr_complex > *":
        r"""__deref__(burst_shaper_cc_sptr self) -> burst_shaper_cc"""
        return _digital_swig1.burst_shaper_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_burst_shaper_cc_sptr

    def make(self, *args, **kwargs) -> "gr::digital::burst_shaper< std::complex< float > >::sptr":
        r"""make(burst_shaper_cc_sptr self, pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_cc_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_make(self, *args, **kwargs)

    def pre_padding(self) -> "int":
        r"""pre_padding(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_pre_padding(self)

    def post_padding(self) -> "int":
        r"""post_padding(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_post_padding(self)

    def prefix_length(self) -> "int":
        r"""prefix_length(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_prefix_length(self)

    def suffix_length(self) -> "int":
        r"""suffix_length(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_suffix_length(self)

    def history(self) -> "unsigned int":
        r"""history(burst_shaper_cc_sptr self) -> unsigned int"""
        return _digital_swig1.burst_shaper_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(burst_shaper_cc_sptr self, int which, int delay)
        declare_sample_delay(burst_shaper_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.burst_shaper_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(burst_shaper_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.burst_shaper_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(burst_shaper_cc_sptr self, int multiple)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(burst_shaper_cc_sptr self) -> double"""
        return _digital_swig1.burst_shaper_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(burst_shaper_cc_sptr self) -> uint64_t"""
        return _digital_swig1.burst_shaper_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(burst_shaper_cc_sptr self) -> uint64_t"""
        return _digital_swig1.burst_shaper_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(burst_shaper_cc_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(burst_shaper_cc_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(burst_shaper_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.burst_shaper_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(burst_shaper_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.burst_shaper_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(burst_shaper_cc_sptr self, std::string level)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(burst_shaper_cc_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(burst_shaper_cc_sptr self, int m)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(burst_shaper_cc_sptr self)"""
        return _digital_swig1.burst_shaper_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(burst_shaper_cc_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(burst_shaper_cc_sptr self, int m)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(burst_shaper_cc_sptr self, int i) -> long"""
        return _digital_swig1.burst_shaper_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(burst_shaper_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(burst_shaper_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.burst_shaper_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(burst_shaper_cc_sptr self, int i) -> long"""
        return _digital_swig1.burst_shaper_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(burst_shaper_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(burst_shaper_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.burst_shaper_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(burst_shaper_cc_sptr self) -> float"""
        return _digital_swig1.burst_shaper_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(burst_shaper_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(burst_shaper_cc_sptr self)"""
        return _digital_swig1.burst_shaper_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(burst_shaper_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.burst_shaper_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(burst_shaper_cc_sptr self) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(burst_shaper_cc_sptr self, int priority) -> int"""
        return _digital_swig1.burst_shaper_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(burst_shaper_cc_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(burst_shaper_cc_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(burst_shaper_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(burst_shaper_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(burst_shaper_cc_sptr self) -> long"""
        return _digital_swig1.burst_shaper_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(burst_shaper_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(burst_shaper_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.burst_shaper_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(burst_shaper_cc_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(burst_shaper_cc_sptr self, std::string name)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(burst_shaper_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.burst_shaper_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(burst_shaper_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(burst_shaper_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(burst_shaper_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_subscribers(self, which_port)

# Register burst_shaper_cc_sptr in _digital_swig1:
_digital_swig1.burst_shaper_cc_sptr_swigregister(burst_shaper_cc_sptr)


burst_shaper_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
burst_shaper_cc = burst_shaper_cc.make

class burst_shaper_ff(object):
    r"""Proxy of C++ gr::digital::burst_shaper< float > class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::burst_shaper< float >::sptr":
        r"""make(pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_ff_sptr"""
        return _digital_swig1.burst_shaper_ff_make(*args, **kwargs)

    def pre_padding(self) -> "int":
        r"""pre_padding(burst_shaper_ff self) -> int"""
        return _digital_swig1.burst_shaper_ff_pre_padding(self)

    def post_padding(self) -> "int":
        r"""post_padding(burst_shaper_ff self) -> int"""
        return _digital_swig1.burst_shaper_ff_post_padding(self)

    def prefix_length(self) -> "int":
        r"""prefix_length(burst_shaper_ff self) -> int"""
        return _digital_swig1.burst_shaper_ff_prefix_length(self)

    def suffix_length(self) -> "int":
        r"""suffix_length(burst_shaper_ff self) -> int"""
        return _digital_swig1.burst_shaper_ff_suffix_length(self)
    __swig_destroy__ = _digital_swig1.delete_burst_shaper_ff

# Register burst_shaper_ff in _digital_swig1:
_digital_swig1.burst_shaper_ff_swigregister(burst_shaper_ff)

def burst_shaper_ff_make(*args, **kwargs) -> "gr::digital::burst_shaper< float >::sptr":
    r"""burst_shaper_ff_make(pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_ff_sptr"""
    return _digital_swig1.burst_shaper_ff_make(*args, **kwargs)

class burst_shaper_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::burst_shaper< float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(burst_shaper_ff_sptr self) -> burst_shaper_ff_sptr
        __init__(burst_shaper_ff_sptr self, burst_shaper_ff p) -> burst_shaper_ff_sptr
        """
        _digital_swig1.burst_shaper_ff_sptr_swiginit(self, _digital_swig1.new_burst_shaper_ff_sptr(*args))

    def __deref__(self) -> "gr::digital::burst_shaper< float > *":
        r"""__deref__(burst_shaper_ff_sptr self) -> burst_shaper_ff"""
        return _digital_swig1.burst_shaper_ff_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_burst_shaper_ff_sptr

    def make(self, *args, **kwargs) -> "gr::digital::burst_shaper< float >::sptr":
        r"""make(burst_shaper_ff_sptr self, pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") -> burst_shaper_ff_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_make(self, *args, **kwargs)

    def pre_padding(self) -> "int":
        r"""pre_padding(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_pre_padding(self)

    def post_padding(self) -> "int":
        r"""post_padding(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_post_padding(self)

    def prefix_length(self) -> "int":
        r"""prefix_length(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_prefix_length(self)

    def suffix_length(self) -> "int":
        r"""suffix_length(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_suffix_length(self)

    def history(self) -> "unsigned int":
        r"""history(burst_shaper_ff_sptr self) -> unsigned int"""
        return _digital_swig1.burst_shaper_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(burst_shaper_ff_sptr self, int which, int delay)
        declare_sample_delay(burst_shaper_ff_sptr self, unsigned int delay)
        """
        return _digital_swig1.burst_shaper_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(burst_shaper_ff_sptr self, int which) -> unsigned int"""
        return _digital_swig1.burst_shaper_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(burst_shaper_ff_sptr self, int multiple)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(burst_shaper_ff_sptr self) -> double"""
        return _digital_swig1.burst_shaper_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(burst_shaper_ff_sptr self) -> uint64_t"""
        return _digital_swig1.burst_shaper_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(burst_shaper_ff_sptr self) -> uint64_t"""
        return _digital_swig1.burst_shaper_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(burst_shaper_ff_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(burst_shaper_ff_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(burst_shaper_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.burst_shaper_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(burst_shaper_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.burst_shaper_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(burst_shaper_ff_sptr self, std::string level)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(burst_shaper_ff_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(burst_shaper_ff_sptr self, int m)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(burst_shaper_ff_sptr self)"""
        return _digital_swig1.burst_shaper_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(burst_shaper_ff_sptr self) -> bool"""
        return _digital_swig1.burst_shaper_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(burst_shaper_ff_sptr self, int m)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(burst_shaper_ff_sptr self, int i) -> long"""
        return _digital_swig1.burst_shaper_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(burst_shaper_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(burst_shaper_ff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.burst_shaper_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(burst_shaper_ff_sptr self, int i) -> long"""
        return _digital_swig1.burst_shaper_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(burst_shaper_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(burst_shaper_ff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.burst_shaper_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(burst_shaper_ff_sptr self, int which) -> float
        pc_input_buffers_full(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(burst_shaper_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(burst_shaper_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(burst_shaper_ff_sptr self, int which) -> float
        pc_output_buffers_full(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(burst_shaper_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(burst_shaper_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(burst_shaper_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(burst_shaper_ff_sptr self) -> float"""
        return _digital_swig1.burst_shaper_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(burst_shaper_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(burst_shaper_ff_sptr self)"""
        return _digital_swig1.burst_shaper_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(burst_shaper_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.burst_shaper_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(burst_shaper_ff_sptr self) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(burst_shaper_ff_sptr self, int priority) -> int"""
        return _digital_swig1.burst_shaper_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(burst_shaper_ff_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(burst_shaper_ff_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(burst_shaper_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(burst_shaper_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(burst_shaper_ff_sptr self) -> long"""
        return _digital_swig1.burst_shaper_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(burst_shaper_ff_sptr self) -> basic_block_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(burst_shaper_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.burst_shaper_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(burst_shaper_ff_sptr self) -> std::string"""
        return _digital_swig1.burst_shaper_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(burst_shaper_ff_sptr self, std::string name)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(burst_shaper_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.burst_shaper_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(burst_shaper_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(burst_shaper_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(burst_shaper_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_subscribers(self, which_port)

# Register burst_shaper_ff_sptr in _digital_swig1:
_digital_swig1.burst_shaper_ff_sptr_swigregister(burst_shaper_ff_sptr)


burst_shaper_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
burst_shaper_ff = burst_shaper_ff.make

class chunks_to_symbols_bc(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::uint8_t,gr_complex > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,std::complex< float > >::sptr":
        r"""make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_bc self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_bc self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_bc_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_bc self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bc_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bc

# Register chunks_to_symbols_bc in _digital_swig1:
_digital_swig1.chunks_to_symbols_bc_swigregister(chunks_to_symbols_bc)

def chunks_to_symbols_bc_make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,std::complex< float > >::sptr":
    r"""chunks_to_symbols_bc_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
    return _digital_swig1.chunks_to_symbols_bc_make(symbol_table, D)

class chunks_to_symbols_bc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::uint8_t,gr_complex > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_bc_sptr self) -> chunks_to_symbols_bc_sptr
        __init__(chunks_to_symbols_bc_sptr self, chunks_to_symbols_bc p) -> chunks_to_symbols_bc_sptr
        """
        _digital_swig1.chunks_to_symbols_bc_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_bc_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::uint8_t,gr_complex > *":
        r"""__deref__(chunks_to_symbols_bc_sptr self) -> chunks_to_symbols_bc"""
        return _digital_swig1.chunks_to_symbols_bc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bc_sptr

    def make(self, symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,std::complex< float > >::sptr":
        r"""make(chunks_to_symbols_bc_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_bc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_bc_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_bc_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_bc_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_bc_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_bc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_bc_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_bc_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_bc_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_bc_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_bc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_bc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_bc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_bc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_bc_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_bc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_bc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_bc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_bc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_bc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_bc_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_bc_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_bc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_bc_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_bc_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_bc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_bc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_bc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_bc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_bc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_bc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_bc_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_bc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_bc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_bc_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_bc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_bc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_bc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_bc_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_bc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_bc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_bc_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_bc_sptr_swigregister(chunks_to_symbols_bc_sptr)


chunks_to_symbols_bc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_bc = chunks_to_symbols_bc.make

class chunks_to_symbols_bf(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::uint8_t,float > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,float >::sptr":
        r"""make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_bf self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_bf self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_bf_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_bf self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bf_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bf

# Register chunks_to_symbols_bf in _digital_swig1:
_digital_swig1.chunks_to_symbols_bf_swigregister(chunks_to_symbols_bf)

def chunks_to_symbols_bf_make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,float >::sptr":
    r"""chunks_to_symbols_bf_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
    return _digital_swig1.chunks_to_symbols_bf_make(symbol_table, D)

class chunks_to_symbols_bf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::uint8_t,float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_bf_sptr self) -> chunks_to_symbols_bf_sptr
        __init__(chunks_to_symbols_bf_sptr self, chunks_to_symbols_bf p) -> chunks_to_symbols_bf_sptr
        """
        _digital_swig1.chunks_to_symbols_bf_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_bf_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::uint8_t,float > *":
        r"""__deref__(chunks_to_symbols_bf_sptr self) -> chunks_to_symbols_bf"""
        return _digital_swig1.chunks_to_symbols_bf_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bf_sptr

    def make(self, symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< unsigned char,float >::sptr":
        r"""make(chunks_to_symbols_bf_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_bf_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_bf_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_bf_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_bf_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_bf_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_bf_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_bf_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_bf_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_bf_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_bf_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_bf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_bf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_bf_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_bf_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_bf_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_bf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_bf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_bf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_bf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_bf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_bf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_bf_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_bf_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_bf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_bf_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_bf_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(chunks_to_symbols_bf_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_bf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_bf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_bf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_bf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_bf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_bf_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_bf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_bf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_bf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_bf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_bf_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_bf_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_bf_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_bf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_bf_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_bf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_bf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_bf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_bf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_bf_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_bf_sptr_swigregister(chunks_to_symbols_bf_sptr)


chunks_to_symbols_bf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_bf = chunks_to_symbols_bf.make

class chunks_to_symbols_ic(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::int32_t,gr_complex > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,std::complex< float > >::sptr":
        r"""make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_ic self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_ic self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_ic_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_ic self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_ic_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_ic

# Register chunks_to_symbols_ic in _digital_swig1:
_digital_swig1.chunks_to_symbols_ic_swigregister(chunks_to_symbols_ic)

def chunks_to_symbols_ic_make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,std::complex< float > >::sptr":
    r"""chunks_to_symbols_ic_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
    return _digital_swig1.chunks_to_symbols_ic_make(symbol_table, D)

class chunks_to_symbols_ic_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::int32_t,gr_complex > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_ic_sptr self) -> chunks_to_symbols_ic_sptr
        __init__(chunks_to_symbols_ic_sptr self, chunks_to_symbols_ic p) -> chunks_to_symbols_ic_sptr
        """
        _digital_swig1.chunks_to_symbols_ic_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_ic_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::int32_t,gr_complex > *":
        r"""__deref__(chunks_to_symbols_ic_sptr self) -> chunks_to_symbols_ic"""
        return _digital_swig1.chunks_to_symbols_ic_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_ic_sptr

    def make(self, symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,std::complex< float > >::sptr":
        r"""make(chunks_to_symbols_ic_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_ic_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_ic_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_ic_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_ic_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_ic_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_ic_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_ic_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_ic_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_ic_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_ic_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_ic_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_ic_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_ic_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_ic_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_ic_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_ic_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_ic_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_ic_sptr self)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_ic_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_ic_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_ic_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_ic_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_ic_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_ic_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_ic_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_ic_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_ic_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_ic_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_ic_sptr self)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_ic_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_ic_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_ic_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_ic_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_ic_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_ic_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_ic_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_ic_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_ic_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_ic_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_ic_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_ic_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_ic_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_ic_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_ic_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_ic_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_ic_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_ic_sptr_swigregister(chunks_to_symbols_ic_sptr)


chunks_to_symbols_ic_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_ic = chunks_to_symbols_ic.make

class chunks_to_symbols_if(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::int32_t,float > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,float >::sptr":
        r"""make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
        return _digital_swig1.chunks_to_symbols_if_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_if self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_if self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_if_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_if self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_if_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_if

# Register chunks_to_symbols_if in _digital_swig1:
_digital_swig1.chunks_to_symbols_if_swigregister(chunks_to_symbols_if)

def chunks_to_symbols_if_make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,float >::sptr":
    r"""chunks_to_symbols_if_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
    return _digital_swig1.chunks_to_symbols_if_make(symbol_table, D)

class chunks_to_symbols_if_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::int32_t,float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_if_sptr self) -> chunks_to_symbols_if_sptr
        __init__(chunks_to_symbols_if_sptr self, chunks_to_symbols_if p) -> chunks_to_symbols_if_sptr
        """
        _digital_swig1.chunks_to_symbols_if_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_if_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::int32_t,float > *":
        r"""__deref__(chunks_to_symbols_if_sptr self) -> chunks_to_symbols_if"""
        return _digital_swig1.chunks_to_symbols_if_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_if_sptr

    def make(self, symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< int,float >::sptr":
        r"""make(chunks_to_symbols_if_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_if_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_if_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_if_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_if_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_if_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_if_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_if_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_if_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_if_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_if_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_if_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_if_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_if_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_if_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_if_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_if_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_if_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_if_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_if_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_if_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_if_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_if_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_if_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_if_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_if_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_if_sptr self)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_if_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_if_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_if_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_if_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_if_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_if_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_if_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_if_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_if_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_if_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_if_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_if_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_if_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_if_sptr self)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_if_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_if_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_if_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_if_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_if_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_if_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_if_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_if_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_if_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_if_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_if_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_if_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_if_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_if_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_if_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_if_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_if_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_if_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_if_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_if_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_if_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_if_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_if_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_if_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_if_sptr_swigregister(chunks_to_symbols_if_sptr)


chunks_to_symbols_if_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_if = chunks_to_symbols_if.make

class chunks_to_symbols_sc(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::int16_t,gr_complex > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,std::complex< float > >::sptr":
        r"""make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_sc self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_sc self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_sc_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_sc self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sc_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sc

# Register chunks_to_symbols_sc in _digital_swig1:
_digital_swig1.chunks_to_symbols_sc_swigregister(chunks_to_symbols_sc)

def chunks_to_symbols_sc_make(symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,std::complex< float > >::sptr":
    r"""chunks_to_symbols_sc_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
    return _digital_swig1.chunks_to_symbols_sc_make(symbol_table, D)

class chunks_to_symbols_sc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::int16_t,gr_complex > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_sc_sptr self) -> chunks_to_symbols_sc_sptr
        __init__(chunks_to_symbols_sc_sptr self, chunks_to_symbols_sc p) -> chunks_to_symbols_sc_sptr
        """
        _digital_swig1.chunks_to_symbols_sc_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_sc_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::int16_t,gr_complex > *":
        r"""__deref__(chunks_to_symbols_sc_sptr self) -> chunks_to_symbols_sc"""
        return _digital_swig1.chunks_to_symbols_sc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sc_sptr

    def make(self, symbol_table: "pmt_vector_cfloat", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,std::complex< float > >::sptr":
        r"""make(chunks_to_symbols_sc_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_D(self)

    def symbol_table(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""symbol_table(chunks_to_symbols_sc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_cfloat") -> "void":
        r"""set_symbol_table(chunks_to_symbols_sc_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_sc_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_sc_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_sc_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_sc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_sc_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_sc_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_sc_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_sc_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_sc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_sc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_sc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_sc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_sc_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_sc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_sc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_sc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_sc_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_sc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_sc_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_sc_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_sc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_sc_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_sc_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_sc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_sc_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_sc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_sc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_sc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_sc_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_sc_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_sc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_sc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_sc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_sc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_sc_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_sc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_sc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_sc_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_sc_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_sc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_sc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_sc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_sc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_sc_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_sc_sptr_swigregister(chunks_to_symbols_sc_sptr)


chunks_to_symbols_sc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_sc = chunks_to_symbols_sc.make

class chunks_to_symbols_sf(object):
    r"""Proxy of C++ gr::digital::chunks_to_symbols< std::int16_t,float > class."""

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

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

    @staticmethod
    def make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,float >::sptr":
        r"""make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_make(symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_sf self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_sf self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_sf_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_sf self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sf_set_symbol_table(self, symbol_table)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sf

# Register chunks_to_symbols_sf in _digital_swig1:
_digital_swig1.chunks_to_symbols_sf_swigregister(chunks_to_symbols_sf)

def chunks_to_symbols_sf_make(symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,float >::sptr":
    r"""chunks_to_symbols_sf_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
    return _digital_swig1.chunks_to_symbols_sf_make(symbol_table, D)

class chunks_to_symbols_sf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::chunks_to_symbols< std::int16_t,float > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(chunks_to_symbols_sf_sptr self) -> chunks_to_symbols_sf_sptr
        __init__(chunks_to_symbols_sf_sptr self, chunks_to_symbols_sf p) -> chunks_to_symbols_sf_sptr
        """
        _digital_swig1.chunks_to_symbols_sf_sptr_swiginit(self, _digital_swig1.new_chunks_to_symbols_sf_sptr(*args))

    def __deref__(self) -> "gr::digital::chunks_to_symbols< std::int16_t,float > *":
        r"""__deref__(chunks_to_symbols_sf_sptr self) -> chunks_to_symbols_sf"""
        return _digital_swig1.chunks_to_symbols_sf_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sf_sptr

    def make(self, symbol_table: "pmt_vector_float", D: "int const"=1) -> "gr::digital::chunks_to_symbols< short,float >::sptr":
        r"""make(chunks_to_symbols_sf_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_make(self, symbol_table, D)

    def D(self) -> "int":
        r"""D(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_D(self)

    def symbol_table(self) -> "std::vector< float,std::allocator< float > >":
        r"""symbol_table(chunks_to_symbols_sf_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_symbol_table(self)

    def set_symbol_table(self, symbol_table: "pmt_vector_float") -> "void":
        r"""set_symbol_table(chunks_to_symbols_sf_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_symbol_table(self, symbol_table)

    def history(self) -> "unsigned int":
        r"""history(chunks_to_symbols_sf_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(chunks_to_symbols_sf_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_sf_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(chunks_to_symbols_sf_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(chunks_to_symbols_sf_sptr self, int multiple)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(chunks_to_symbols_sf_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(chunks_to_symbols_sf_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(chunks_to_symbols_sf_sptr self) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(chunks_to_symbols_sf_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(chunks_to_symbols_sf_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(chunks_to_symbols_sf_sptr self, std::string level)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(chunks_to_symbols_sf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(chunks_to_symbols_sf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(chunks_to_symbols_sf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(chunks_to_symbols_sf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(chunks_to_symbols_sf_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_sf_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(chunks_to_symbols_sf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(chunks_to_symbols_sf_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_sf_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(chunks_to_symbols_sf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(chunks_to_symbols_sf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(chunks_to_symbols_sf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(chunks_to_symbols_sf_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(chunks_to_symbols_sf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(chunks_to_symbols_sf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(chunks_to_symbols_sf_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(chunks_to_symbols_sf_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(chunks_to_symbols_sf_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(chunks_to_symbols_sf_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(chunks_to_symbols_sf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(chunks_to_symbols_sf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(chunks_to_symbols_sf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(chunks_to_symbols_sf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_subscribers(self, which_port)

# Register chunks_to_symbols_sf_sptr in _digital_swig1:
_digital_swig1.chunks_to_symbols_sf_sptr_swigregister(chunks_to_symbols_sf_sptr)


chunks_to_symbols_sf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
chunks_to_symbols_sf = chunks_to_symbols_sf.make

class clock_recovery_mm_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::clock_recovery_mm_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__(clock_recovery_mm_cc_sptr self) -> clock_recovery_mm_cc_sptr
        __init__(clock_recovery_mm_cc_sptr self, clock_recovery_mm_cc p) -> clock_recovery_mm_cc_sptr
        """
        _digital_swig1.clock_recovery_mm_cc_sptr_swiginit(self, _digital_swig1.new_clock_recovery_mm_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::clock_recovery_mm_cc *":
        r"""__deref__(clock_recovery_mm_cc_sptr self) -> clock_recovery_mm_cc"""
        return _digital_swig1.clock_recovery_mm_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_cc_sptr

    def make(self, omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_cc::sptr":
        r"""make(clock_recovery_mm_cc_sptr self, float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit)

    def mu(self) -> "float":
        r"""mu(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_mu(self)

    def omega(self) -> "float":
        r"""omega(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_omega(self)

    def gain_mu(self) -> "float":
        r"""gain_mu(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_gain_mu(self)

    def gain_omega(self) -> "float":
        r"""gain_omega(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_gain_omega(self)

    def set_verbose(self, verbose: "bool") -> "void":
        r"""set_verbose(clock_recovery_mm_cc_sptr self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_verbose(self, verbose)

    def set_gain_mu(self, gain_mu: "float") -> "void":
        r"""set_gain_mu(clock_recovery_mm_cc_sptr self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_gain_mu(self, gain_mu)

    def set_gain_omega(self, gain_omega: "float") -> "void":
        r"""set_gain_omega(clock_recovery_mm_cc_sptr self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_gain_omega(self, gain_omega)

    def set_mu(self, mu: "float") -> "void":
        r"""set_mu(clock_recovery_mm_cc_sptr self, float mu)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_mu(self, mu)

    def set_omega(self, omega: "float") -> "void":
        r"""set_omega(clock_recovery_mm_cc_sptr self, float omega)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_omega(self, omega)

    def history(self) -> "unsigned int":
        r"""history(clock_recovery_mm_cc_sptr self) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(clock_recovery_mm_cc_sptr self, int which, int delay)
        declare_sample_delay(clock_recovery_mm_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(clock_recovery_mm_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(clock_recovery_mm_cc_sptr self, int multiple)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(clock_recovery_mm_cc_sptr self) -> double"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(clock_recovery_mm_cc_sptr self) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(clock_recovery_mm_cc_sptr self) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(clock_recovery_mm_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(clock_recovery_mm_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(clock_recovery_mm_cc_sptr self, std::string level)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(clock_recovery_mm_cc_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(clock_recovery_mm_cc_sptr self)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(clock_recovery_mm_cc_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(clock_recovery_mm_cc_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(clock_recovery_mm_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(clock_recovery_mm_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(clock_recovery_mm_cc_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(clock_recovery_mm_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(clock_recovery_mm_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(clock_recovery_mm_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(clock_recovery_mm_cc_sptr self)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(clock_recovery_mm_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(clock_recovery_mm_cc_sptr self, int priority) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(clock_recovery_mm_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(clock_recovery_mm_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(clock_recovery_mm_cc_sptr self) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(clock_recovery_mm_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(clock_recovery_mm_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(clock_recovery_mm_cc_sptr self, std::string name)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(clock_recovery_mm_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(clock_recovery_mm_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(clock_recovery_mm_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(clock_recovery_mm_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_subscribers(self, which_port)

# Register clock_recovery_mm_cc_sptr in _digital_swig1:
_digital_swig1.clock_recovery_mm_cc_sptr_swigregister(clock_recovery_mm_cc_sptr)


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

class clock_recovery_mm_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::clock_recovery_mm_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(clock_recovery_mm_ff_sptr self) -> clock_recovery_mm_ff_sptr
        __init__(clock_recovery_mm_ff_sptr self, clock_recovery_mm_ff p) -> clock_recovery_mm_ff_sptr
        """
        _digital_swig1.clock_recovery_mm_ff_sptr_swiginit(self, _digital_swig1.new_clock_recovery_mm_ff_sptr(*args))

    def __deref__(self) -> "gr::digital::clock_recovery_mm_ff *":
        r"""__deref__(clock_recovery_mm_ff_sptr self) -> clock_recovery_mm_ff"""
        return _digital_swig1.clock_recovery_mm_ff_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_ff_sptr

    def make(self, omega: "float", gain_omega: "float", mu: "float", gain_mu: "float", omega_relative_limit: "float") -> "gr::digital::clock_recovery_mm_ff::sptr":
        r"""make(clock_recovery_mm_ff_sptr self, float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit)

    def mu(self) -> "float":
        r"""mu(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_mu(self)

    def omega(self) -> "float":
        r"""omega(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_omega(self)

    def gain_mu(self) -> "float":
        r"""gain_mu(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_gain_mu(self)

    def gain_omega(self) -> "float":
        r"""gain_omega(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_gain_omega(self)

    def set_verbose(self, verbose: "bool") -> "void":
        r"""set_verbose(clock_recovery_mm_ff_sptr self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_verbose(self, verbose)

    def set_gain_mu(self, gain_mu: "float") -> "void":
        r"""set_gain_mu(clock_recovery_mm_ff_sptr self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_gain_mu(self, gain_mu)

    def set_gain_omega(self, gain_omega: "float") -> "void":
        r"""set_gain_omega(clock_recovery_mm_ff_sptr self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_gain_omega(self, gain_omega)

    def set_mu(self, mu: "float") -> "void":
        r"""set_mu(clock_recovery_mm_ff_sptr self, float mu)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_mu(self, mu)

    def set_omega(self, omega: "float") -> "void":
        r"""set_omega(clock_recovery_mm_ff_sptr self, float omega)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_omega(self, omega)

    def history(self) -> "unsigned int":
        r"""history(clock_recovery_mm_ff_sptr self) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(clock_recovery_mm_ff_sptr self, int which, int delay)
        declare_sample_delay(clock_recovery_mm_ff_sptr self, unsigned int delay)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(clock_recovery_mm_ff_sptr self, int which) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(clock_recovery_mm_ff_sptr self, int multiple)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(clock_recovery_mm_ff_sptr self) -> double"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(clock_recovery_mm_ff_sptr self) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(clock_recovery_mm_ff_sptr self) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(clock_recovery_mm_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(clock_recovery_mm_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(clock_recovery_mm_ff_sptr self, std::string level)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(clock_recovery_mm_ff_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(clock_recovery_mm_ff_sptr self)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(clock_recovery_mm_ff_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(clock_recovery_mm_ff_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(clock_recovery_mm_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(clock_recovery_mm_ff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(clock_recovery_mm_ff_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(clock_recovery_mm_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(clock_recovery_mm_ff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(clock_recovery_mm_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(clock_recovery_mm_ff_sptr self)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(clock_recovery_mm_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(clock_recovery_mm_ff_sptr self, int priority) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(clock_recovery_mm_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(clock_recovery_mm_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(clock_recovery_mm_ff_sptr self) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(clock_recovery_mm_ff_sptr self) -> basic_block_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(clock_recovery_mm_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(clock_recovery_mm_ff_sptr self, std::string name)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(clock_recovery_mm_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(clock_recovery_mm_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(clock_recovery_mm_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(clock_recovery_mm_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_subscribers(self, which_port)

# Register clock_recovery_mm_ff_sptr in _digital_swig1:
_digital_swig1.clock_recovery_mm_ff_sptr_swigregister(clock_recovery_mm_ff_sptr)


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

class diff_decoder_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::diff_decoder_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(diff_decoder_bb_sptr self) -> diff_decoder_bb_sptr
        __init__(diff_decoder_bb_sptr self, diff_decoder_bb p) -> diff_decoder_bb_sptr
        """
        _digital_swig1.diff_decoder_bb_sptr_swiginit(self, _digital_swig1.new_diff_decoder_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::diff_decoder_bb *":
        r"""__deref__(diff_decoder_bb_sptr self) -> diff_decoder_bb"""
        return _digital_swig1.diff_decoder_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_diff_decoder_bb_sptr

    def make(self, modulus: "unsigned int") -> "gr::digital::diff_decoder_bb::sptr":
        r"""make(diff_decoder_bb_sptr self, unsigned int modulus) -> diff_decoder_bb_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_make(self, modulus)

    def history(self) -> "unsigned int":
        r"""history(diff_decoder_bb_sptr self) -> unsigned int"""
        return _digital_swig1.diff_decoder_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(diff_decoder_bb_sptr self, int which, int delay)
        declare_sample_delay(diff_decoder_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_decoder_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(diff_decoder_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_decoder_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(diff_decoder_bb_sptr self, int multiple)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(diff_decoder_bb_sptr self) -> double"""
        return _digital_swig1.diff_decoder_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(diff_decoder_bb_sptr self) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(diff_decoder_bb_sptr self) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(diff_decoder_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(diff_decoder_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(diff_decoder_bb_sptr self, std::string level)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(diff_decoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(diff_decoder_bb_sptr self)"""
        return _digital_swig1.diff_decoder_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(diff_decoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(diff_decoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(diff_decoder_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_decoder_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_decoder_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(diff_decoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(diff_decoder_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_decoder_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_decoder_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(diff_decoder_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(diff_decoder_bb_sptr self)"""
        return _digital_swig1.diff_decoder_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(diff_decoder_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_decoder_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(diff_decoder_bb_sptr self, int priority) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(diff_decoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(diff_decoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(diff_decoder_bb_sptr self) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(diff_decoder_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(diff_decoder_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(diff_decoder_bb_sptr self, std::string name)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(diff_decoder_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.diff_decoder_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(diff_decoder_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(diff_decoder_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(diff_decoder_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_subscribers(self, which_port)

# Register diff_decoder_bb_sptr in _digital_swig1:
_digital_swig1.diff_decoder_bb_sptr_swigregister(diff_decoder_bb_sptr)


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

class diff_encoder_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::diff_encoder_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(diff_encoder_bb_sptr self) -> diff_encoder_bb_sptr
        __init__(diff_encoder_bb_sptr self, diff_encoder_bb p) -> diff_encoder_bb_sptr
        """
        _digital_swig1.diff_encoder_bb_sptr_swiginit(self, _digital_swig1.new_diff_encoder_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::diff_encoder_bb *":
        r"""__deref__(diff_encoder_bb_sptr self) -> diff_encoder_bb"""
        return _digital_swig1.diff_encoder_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_diff_encoder_bb_sptr

    def make(self, modulus: "unsigned int") -> "gr::digital::diff_encoder_bb::sptr":
        r"""make(diff_encoder_bb_sptr self, unsigned int modulus) -> diff_encoder_bb_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_make(self, modulus)

    def history(self) -> "unsigned int":
        r"""history(diff_encoder_bb_sptr self) -> unsigned int"""
        return _digital_swig1.diff_encoder_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(diff_encoder_bb_sptr self, int which, int delay)
        declare_sample_delay(diff_encoder_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_encoder_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(diff_encoder_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_encoder_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(diff_encoder_bb_sptr self, int multiple)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(diff_encoder_bb_sptr self) -> double"""
        return _digital_swig1.diff_encoder_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(diff_encoder_bb_sptr self) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(diff_encoder_bb_sptr self) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(diff_encoder_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(diff_encoder_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(diff_encoder_bb_sptr self, std::string level)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(diff_encoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(diff_encoder_bb_sptr self)"""
        return _digital_swig1.diff_encoder_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(diff_encoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(diff_encoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(diff_encoder_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_encoder_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_encoder_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(diff_encoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(diff_encoder_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_encoder_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_encoder_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(diff_encoder_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(diff_encoder_bb_sptr self)"""
        return _digital_swig1.diff_encoder_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(diff_encoder_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_encoder_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(diff_encoder_bb_sptr self, int priority) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(diff_encoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(diff_encoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(diff_encoder_bb_sptr self) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(diff_encoder_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(diff_encoder_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(diff_encoder_bb_sptr self, std::string name)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(diff_encoder_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.diff_encoder_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(diff_encoder_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(diff_encoder_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(diff_encoder_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_subscribers(self, which_port)

# Register diff_encoder_bb_sptr in _digital_swig1:
_digital_swig1.diff_encoder_bb_sptr_swigregister(diff_encoder_bb_sptr)


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

class diff_phasor_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::diff_phasor_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__(diff_phasor_cc_sptr self) -> diff_phasor_cc_sptr
        __init__(diff_phasor_cc_sptr self, diff_phasor_cc p) -> diff_phasor_cc_sptr
        """
        _digital_swig1.diff_phasor_cc_sptr_swiginit(self, _digital_swig1.new_diff_phasor_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::diff_phasor_cc *":
        r"""__deref__(diff_phasor_cc_sptr self) -> diff_phasor_cc"""
        return _digital_swig1.diff_phasor_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_diff_phasor_cc_sptr

    def make(self) -> "gr::digital::diff_phasor_cc::sptr":
        r"""make(diff_phasor_cc_sptr self) -> diff_phasor_cc_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(diff_phasor_cc_sptr self) -> unsigned int"""
        return _digital_swig1.diff_phasor_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(diff_phasor_cc_sptr self, int which, int delay)
        declare_sample_delay(diff_phasor_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_phasor_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(diff_phasor_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_phasor_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(diff_phasor_cc_sptr self, int multiple)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(diff_phasor_cc_sptr self) -> double"""
        return _digital_swig1.diff_phasor_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(diff_phasor_cc_sptr self) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(diff_phasor_cc_sptr self) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(diff_phasor_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(diff_phasor_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(diff_phasor_cc_sptr self, std::string level)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(diff_phasor_cc_sptr self, int m)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(diff_phasor_cc_sptr self)"""
        return _digital_swig1.diff_phasor_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(diff_phasor_cc_sptr self, int m)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(diff_phasor_cc_sptr self, int i) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(diff_phasor_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_phasor_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_phasor_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(diff_phasor_cc_sptr self, int i) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(diff_phasor_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_phasor_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_phasor_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(diff_phasor_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(diff_phasor_cc_sptr self)"""
        return _digital_swig1.diff_phasor_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(diff_phasor_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_phasor_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(diff_phasor_cc_sptr self, int priority) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(diff_phasor_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(diff_phasor_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(diff_phasor_cc_sptr self) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(diff_phasor_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(diff_phasor_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(diff_phasor_cc_sptr self, std::string name)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(diff_phasor_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.diff_phasor_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(diff_phasor_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(diff_phasor_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(diff_phasor_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_subscribers(self, which_port)

# Register diff_phasor_cc_sptr in _digital_swig1:
_digital_swig1.diff_phasor_cc_sptr_swigregister(diff_phasor_cc_sptr)


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

class fll_band_edge_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::fll_band_edge_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__(fll_band_edge_cc_sptr self) -> fll_band_edge_cc_sptr
        __init__(fll_band_edge_cc_sptr self, fll_band_edge_cc p) -> fll_band_edge_cc_sptr
        """
        _digital_swig1.fll_band_edge_cc_sptr_swiginit(self, _digital_swig1.new_fll_band_edge_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::fll_band_edge_cc *":
        r"""__deref__(fll_band_edge_cc_sptr self) -> fll_band_edge_cc"""
        return _digital_swig1.fll_band_edge_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_fll_band_edge_cc_sptr

    def make(self, samps_per_sym: "float", rolloff: "float", filter_size: "int", bandwidth: "float") -> "gr::digital::fll_band_edge_cc::sptr":
        r"""make(fll_band_edge_cc_sptr self, float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_make(self, samps_per_sym, rolloff, filter_size, bandwidth)

    def set_samples_per_symbol(self, sps: "float") -> "void":
        r"""set_samples_per_symbol(fll_band_edge_cc_sptr self, float sps)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_samples_per_symbol(self, sps)

    def set_rolloff(self, rolloff: "float") -> "void":
        r"""set_rolloff(fll_band_edge_cc_sptr self, float rolloff)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_rolloff(self, rolloff)

    def set_filter_size(self, filter_size: "int") -> "void":
        r"""set_filter_size(fll_band_edge_cc_sptr self, int filter_size)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_filter_size(self, filter_size)

    def samples_per_symbol(self) -> "float":
        r"""samples_per_symbol(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_samples_per_symbol(self)

    def rolloff(self) -> "float":
        r"""rolloff(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_rolloff(self)

    def filter_size(self) -> "int":
        r"""filter_size(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_filter_size(self)

    def print_taps(self) -> "void":
        r"""print_taps(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_print_taps(self)

    def history(self) -> "unsigned int":
        r"""history(fll_band_edge_cc_sptr self) -> unsigned int"""
        return _digital_swig1.fll_band_edge_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fll_band_edge_cc_sptr self, int which, int delay)
        declare_sample_delay(fll_band_edge_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fll_band_edge_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.fll_band_edge_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fll_band_edge_cc_sptr self, int multiple)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fll_band_edge_cc_sptr self) -> double"""
        return _digital_swig1.fll_band_edge_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fll_band_edge_cc_sptr self) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fll_band_edge_cc_sptr self) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fll_band_edge_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fll_band_edge_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fll_band_edge_cc_sptr self, std::string level)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fll_band_edge_cc_sptr self, int m)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fll_band_edge_cc_sptr self, int m)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fll_band_edge_cc_sptr self, int i) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fll_band_edge_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(fll_band_edge_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fll_band_edge_cc_sptr self, int i) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fll_band_edge_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(fll_band_edge_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fll_band_edge_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fll_band_edge_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.fll_band_edge_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fll_band_edge_cc_sptr self, int priority) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fll_band_edge_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fll_band_edge_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fll_band_edge_cc_sptr self) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fll_band_edge_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fll_band_edge_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fll_band_edge_cc_sptr self, std::string name)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fll_band_edge_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.fll_band_edge_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fll_band_edge_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fll_band_edge_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fll_band_edge_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(fll_band_edge_cc_sptr self, float error)"""
        return _digital_swig1.fll_band_edge_cc_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(fll_band_edge_cc_sptr self, float bw)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(fll_band_edge_cc_sptr self, float df)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(fll_band_edge_cc_sptr self, float alpha)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(fll_band_edge_cc_sptr self, float beta)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(fll_band_edge_cc_sptr self, float phase)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_min_freq(self)

# Register fll_band_edge_cc_sptr in _digital_swig1:
_digital_swig1.fll_band_edge_cc_sptr_swigregister(fll_band_edge_cc_sptr)


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

class framer_sink_1_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::framer_sink_1 > 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__(framer_sink_1_sptr self) -> framer_sink_1_sptr
        __init__(framer_sink_1_sptr self, framer_sink_1 p) -> framer_sink_1_sptr
        """
        _digital_swig1.framer_sink_1_sptr_swiginit(self, _digital_swig1.new_framer_sink_1_sptr(*args))

    def __deref__(self) -> "gr::digital::framer_sink_1 *":
        r"""__deref__(framer_sink_1_sptr self) -> framer_sink_1"""
        return _digital_swig1.framer_sink_1_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_framer_sink_1_sptr

    def make(self, target_queue: "msg_queue_sptr") -> "gr::digital::framer_sink_1::sptr":
        r"""make(framer_sink_1_sptr self, msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
        return _digital_swig1.framer_sink_1_sptr_make(self, target_queue)

    def history(self) -> "unsigned int":
        r"""history(framer_sink_1_sptr self) -> unsigned int"""
        return _digital_swig1.framer_sink_1_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(framer_sink_1_sptr self, int which, int delay)
        declare_sample_delay(framer_sink_1_sptr self, unsigned int delay)
        """
        return _digital_swig1.framer_sink_1_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(framer_sink_1_sptr self, int which) -> unsigned int"""
        return _digital_swig1.framer_sink_1_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(framer_sink_1_sptr self, int multiple)"""
        return _digital_swig1.framer_sink_1_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(framer_sink_1_sptr self) -> double"""
        return _digital_swig1.framer_sink_1_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(framer_sink_1_sptr self) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(framer_sink_1_sptr self) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(framer_sink_1_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(framer_sink_1_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(framer_sink_1_sptr self, std::string level)"""
        return _digital_swig1.framer_sink_1_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(framer_sink_1_sptr self, int m)"""
        return _digital_swig1.framer_sink_1_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(framer_sink_1_sptr self)"""
        return _digital_swig1.framer_sink_1_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(framer_sink_1_sptr self, int m)"""
        return _digital_swig1.framer_sink_1_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(framer_sink_1_sptr self, int i) -> long"""
        return _digital_swig1.framer_sink_1_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(framer_sink_1_sptr self, long max_output_buffer)
        set_max_output_buffer(framer_sink_1_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.framer_sink_1_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(framer_sink_1_sptr self, int i) -> long"""
        return _digital_swig1.framer_sink_1_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(framer_sink_1_sptr self, long min_output_buffer)
        set_min_output_buffer(framer_sink_1_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.framer_sink_1_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(framer_sink_1_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.framer_sink_1_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(framer_sink_1_sptr self)"""
        return _digital_swig1.framer_sink_1_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(framer_sink_1_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.framer_sink_1_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(framer_sink_1_sptr self, int priority) -> int"""
        return _digital_swig1.framer_sink_1_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(framer_sink_1_sptr self) -> io_signature_sptr"""
        return _digital_swig1.framer_sink_1_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(framer_sink_1_sptr self) -> io_signature_sptr"""
        return _digital_swig1.framer_sink_1_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(framer_sink_1_sptr self) -> long"""
        return _digital_swig1.framer_sink_1_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(framer_sink_1_sptr self) -> basic_block_sptr"""
        return _digital_swig1.framer_sink_1_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(framer_sink_1_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(framer_sink_1_sptr self, std::string name)"""
        return _digital_swig1.framer_sink_1_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(framer_sink_1_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.framer_sink_1_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(framer_sink_1_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(framer_sink_1_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(framer_sink_1_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_subscribers(self, which_port)

# Register framer_sink_1_sptr in _digital_swig1:
_digital_swig1.framer_sink_1_sptr_swigregister(framer_sink_1_sptr)


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

class glfsr_source_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::glfsr_source_b > 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__(glfsr_source_b_sptr self) -> glfsr_source_b_sptr
        __init__(glfsr_source_b_sptr self, glfsr_source_b p) -> glfsr_source_b_sptr
        """
        _digital_swig1.glfsr_source_b_sptr_swiginit(self, _digital_swig1.new_glfsr_source_b_sptr(*args))

    def __deref__(self) -> "gr::digital::glfsr_source_b *":
        r"""__deref__(glfsr_source_b_sptr self) -> glfsr_source_b"""
        return _digital_swig1.glfsr_source_b_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_glfsr_source_b_sptr

    def make(self, degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=0x1) -> "gr::digital::glfsr_source_b::sptr":
        r"""make(glfsr_source_b_sptr self, unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=0x1) -> glfsr_source_b_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_make(self, degree, repeat, mask, seed)

    def period(self) -> "uint32_t":
        r"""period(glfsr_source_b_sptr self) -> uint32_t"""
        return _digital_swig1.glfsr_source_b_sptr_period(self)

    def mask(self) -> "uint32_t":
        r"""mask(glfsr_source_b_sptr self) -> uint32_t"""
        return _digital_swig1.glfsr_source_b_sptr_mask(self)

    def history(self) -> "unsigned int":
        r"""history(glfsr_source_b_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(glfsr_source_b_sptr self, int which, int delay)
        declare_sample_delay(glfsr_source_b_sptr self, unsigned int delay)
        """
        return _digital_swig1.glfsr_source_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(glfsr_source_b_sptr self, int which) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(glfsr_source_b_sptr self, int multiple)"""
        return _digital_swig1.glfsr_source_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(glfsr_source_b_sptr self) -> double"""
        return _digital_swig1.glfsr_source_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(glfsr_source_b_sptr self) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(glfsr_source_b_sptr self) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(glfsr_source_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(glfsr_source_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(glfsr_source_b_sptr self, std::string level)"""
        return _digital_swig1.glfsr_source_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(glfsr_source_b_sptr self, int m)"""
        return _digital_swig1.glfsr_source_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(glfsr_source_b_sptr self)"""
        return _digital_swig1.glfsr_source_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(glfsr_source_b_sptr self, int m)"""
        return _digital_swig1.glfsr_source_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(glfsr_source_b_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(glfsr_source_b_sptr self, long max_output_buffer)
        set_max_output_buffer(glfsr_source_b_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.glfsr_source_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(glfsr_source_b_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(glfsr_source_b_sptr self, long min_output_buffer)
        set_min_output_buffer(glfsr_source_b_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.glfsr_source_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(glfsr_source_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.glfsr_source_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(glfsr_source_b_sptr self)"""
        return _digital_swig1.glfsr_source_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(glfsr_source_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.glfsr_source_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(glfsr_source_b_sptr self, int priority) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(glfsr_source_b_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(glfsr_source_b_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(glfsr_source_b_sptr self) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(glfsr_source_b_sptr self) -> basic_block_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(glfsr_source_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(glfsr_source_b_sptr self, std::string name)"""
        return _digital_swig1.glfsr_source_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(glfsr_source_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.glfsr_source_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(glfsr_source_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(glfsr_source_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(glfsr_source_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_subscribers(self, which_port)

# Register glfsr_source_b_sptr in _digital_swig1:
_digital_swig1.glfsr_source_b_sptr_swigregister(glfsr_source_b_sptr)


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

class glfsr_source_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::glfsr_source_f > class."""

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

    def __init__(self, *args):
        r"""
        __init__(glfsr_source_f_sptr self) -> glfsr_source_f_sptr
        __init__(glfsr_source_f_sptr self, glfsr_source_f p) -> glfsr_source_f_sptr
        """
        _digital_swig1.glfsr_source_f_sptr_swiginit(self, _digital_swig1.new_glfsr_source_f_sptr(*args))

    def __deref__(self) -> "gr::digital::glfsr_source_f *":
        r"""__deref__(glfsr_source_f_sptr self) -> glfsr_source_f"""
        return _digital_swig1.glfsr_source_f_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_glfsr_source_f_sptr

    def make(self, degree: "unsigned int", repeat: "bool"=True, mask: "uint32_t"=0, seed: "uint32_t"=1) -> "gr::digital::glfsr_source_f::sptr":
        r"""make(glfsr_source_f_sptr self, unsigned int degree, bool repeat=True, uint32_t mask=0, uint32_t seed=1) -> glfsr_source_f_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_make(self, degree, repeat, mask, seed)

    def period(self) -> "uint32_t":
        r"""period(glfsr_source_f_sptr self) -> uint32_t"""
        return _digital_swig1.glfsr_source_f_sptr_period(self)

    def mask(self) -> "uint32_t":
        r"""mask(glfsr_source_f_sptr self) -> uint32_t"""
        return _digital_swig1.glfsr_source_f_sptr_mask(self)

    def history(self) -> "unsigned int":
        r"""history(glfsr_source_f_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(glfsr_source_f_sptr self, int which, int delay)
        declare_sample_delay(glfsr_source_f_sptr self, unsigned int delay)
        """
        return _digital_swig1.glfsr_source_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(glfsr_source_f_sptr self, int which) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(glfsr_source_f_sptr self, int multiple)"""
        return _digital_swig1.glfsr_source_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(glfsr_source_f_sptr self) -> double"""
        return _digital_swig1.glfsr_source_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(glfsr_source_f_sptr self) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(glfsr_source_f_sptr self) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(glfsr_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(glfsr_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(glfsr_source_f_sptr self, std::string level)"""
        return _digital_swig1.glfsr_source_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(glfsr_source_f_sptr self, int m)"""
        return _digital_swig1.glfsr_source_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(glfsr_source_f_sptr self)"""
        return _digital_swig1.glfsr_source_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(glfsr_source_f_sptr self, int m)"""
        return _digital_swig1.glfsr_source_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(glfsr_source_f_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(glfsr_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(glfsr_source_f_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.glfsr_source_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(glfsr_source_f_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(glfsr_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(glfsr_source_f_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.glfsr_source_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(glfsr_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.glfsr_source_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(glfsr_source_f_sptr self)"""
        return _digital_swig1.glfsr_source_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(glfsr_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.glfsr_source_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(glfsr_source_f_sptr self, int priority) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(glfsr_source_f_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(glfsr_source_f_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(glfsr_source_f_sptr self) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(glfsr_source_f_sptr self) -> basic_block_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(glfsr_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(glfsr_source_f_sptr self, std::string name)"""
        return _digital_swig1.glfsr_source_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(glfsr_source_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.glfsr_source_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(glfsr_source_f_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(glfsr_source_f_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(glfsr_source_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_subscribers(self, which_port)

# Register glfsr_source_f_sptr in _digital_swig1:
_digital_swig1.glfsr_source_f_sptr_swigregister(glfsr_source_f_sptr)


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

class hdlc_deframer_bp_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::hdlc_deframer_bp > 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__(hdlc_deframer_bp_sptr self) -> hdlc_deframer_bp_sptr
        __init__(hdlc_deframer_bp_sptr self, hdlc_deframer_bp p) -> hdlc_deframer_bp_sptr
        """
        _digital_swig1.hdlc_deframer_bp_sptr_swiginit(self, _digital_swig1.new_hdlc_deframer_bp_sptr(*args))

    def __deref__(self) -> "gr::digital::hdlc_deframer_bp *":
        r"""__deref__(hdlc_deframer_bp_sptr self) -> hdlc_deframer_bp"""
        return _digital_swig1.hdlc_deframer_bp_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_hdlc_deframer_bp_sptr

    def make(self, length_min: "int", length_max: "int") -> "gr::digital::hdlc_deframer_bp::sptr":
        r"""make(hdlc_deframer_bp_sptr self, int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_make(self, length_min, length_max)

    def history(self) -> "unsigned int":
        r"""history(hdlc_deframer_bp_sptr self) -> unsigned int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(hdlc_deframer_bp_sptr self, int which, int delay)
        declare_sample_delay(hdlc_deframer_bp_sptr self, unsigned int delay)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(hdlc_deframer_bp_sptr self, int which) -> unsigned int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(hdlc_deframer_bp_sptr self, int multiple)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(hdlc_deframer_bp_sptr self) -> double"""
        return _digital_swig1.hdlc_deframer_bp_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(hdlc_deframer_bp_sptr self) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(hdlc_deframer_bp_sptr self) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(hdlc_deframer_bp_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(hdlc_deframer_bp_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(hdlc_deframer_bp_sptr self, std::string level)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(hdlc_deframer_bp_sptr self, int m)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(hdlc_deframer_bp_sptr self)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(hdlc_deframer_bp_sptr self, int m)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(hdlc_deframer_bp_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(hdlc_deframer_bp_sptr self, long max_output_buffer)
        set_max_output_buffer(hdlc_deframer_bp_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(hdlc_deframer_bp_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(hdlc_deframer_bp_sptr self, long min_output_buffer)
        set_min_output_buffer(hdlc_deframer_bp_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(hdlc_deframer_bp_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(hdlc_deframer_bp_sptr self)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(hdlc_deframer_bp_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.hdlc_deframer_bp_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(hdlc_deframer_bp_sptr self, int priority) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(hdlc_deframer_bp_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(hdlc_deframer_bp_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(hdlc_deframer_bp_sptr self) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(hdlc_deframer_bp_sptr self) -> basic_block_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(hdlc_deframer_bp_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(hdlc_deframer_bp_sptr self, std::string name)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(hdlc_deframer_bp_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.hdlc_deframer_bp_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(hdlc_deframer_bp_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(hdlc_deframer_bp_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(hdlc_deframer_bp_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_subscribers(self, which_port)

# Register hdlc_deframer_bp_sptr in _digital_swig1:
_digital_swig1.hdlc_deframer_bp_sptr_swigregister(hdlc_deframer_bp_sptr)


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

class hdlc_framer_pb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::hdlc_framer_pb > 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__(hdlc_framer_pb_sptr self) -> hdlc_framer_pb_sptr
        __init__(hdlc_framer_pb_sptr self, hdlc_framer_pb p) -> hdlc_framer_pb_sptr
        """
        _digital_swig1.hdlc_framer_pb_sptr_swiginit(self, _digital_swig1.new_hdlc_framer_pb_sptr(*args))

    def __deref__(self) -> "gr::digital::hdlc_framer_pb *":
        r"""__deref__(hdlc_framer_pb_sptr self) -> hdlc_framer_pb"""
        return _digital_swig1.hdlc_framer_pb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_hdlc_framer_pb_sptr

    def make(self, frame_tag_name: "std::string const") -> "gr::digital::hdlc_framer_pb::sptr":
        r"""make(hdlc_framer_pb_sptr self, std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_make(self, frame_tag_name)

    def history(self) -> "unsigned int":
        r"""history(hdlc_framer_pb_sptr self) -> unsigned int"""
        return _digital_swig1.hdlc_framer_pb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(hdlc_framer_pb_sptr self, int which, int delay)
        declare_sample_delay(hdlc_framer_pb_sptr self, unsigned int delay)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(hdlc_framer_pb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.hdlc_framer_pb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(hdlc_framer_pb_sptr self, int multiple)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(hdlc_framer_pb_sptr self) -> double"""
        return _digital_swig1.hdlc_framer_pb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(hdlc_framer_pb_sptr self) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(hdlc_framer_pb_sptr self) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(hdlc_framer_pb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(hdlc_framer_pb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(hdlc_framer_pb_sptr self, std::string level)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(hdlc_framer_pb_sptr self, int m)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(hdlc_framer_pb_sptr self)"""
        return _digital_swig1.hdlc_framer_pb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(hdlc_framer_pb_sptr self, int m)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(hdlc_framer_pb_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(hdlc_framer_pb_sptr self, long max_output_buffer)
        set_max_output_buffer(hdlc_framer_pb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(hdlc_framer_pb_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(hdlc_framer_pb_sptr self, long min_output_buffer)
        set_min_output_buffer(hdlc_framer_pb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(hdlc_framer_pb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(hdlc_framer_pb_sptr self)"""
        return _digital_swig1.hdlc_framer_pb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(hdlc_framer_pb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.hdlc_framer_pb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(hdlc_framer_pb_sptr self, int priority) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(hdlc_framer_pb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(hdlc_framer_pb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(hdlc_framer_pb_sptr self) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(hdlc_framer_pb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(hdlc_framer_pb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(hdlc_framer_pb_sptr self, std::string name)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(hdlc_framer_pb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.hdlc_framer_pb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(hdlc_framer_pb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(hdlc_framer_pb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(hdlc_framer_pb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_subscribers(self, which_port)

# Register hdlc_framer_pb_sptr in _digital_swig1:
_digital_swig1.hdlc_framer_pb_sptr_swigregister(hdlc_framer_pb_sptr)


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

class header_payload_demux_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_payload_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__(header_payload_demux_sptr self) -> header_payload_demux_sptr
        __init__(header_payload_demux_sptr self, header_payload_demux p) -> header_payload_demux_sptr
        """
        _digital_swig1.header_payload_demux_sptr_swiginit(self, _digital_swig1.new_header_payload_demux_sptr(*args))

    def __deref__(self) -> "gr::digital::header_payload_demux *":
        r"""__deref__(header_payload_demux_sptr self) -> header_payload_demux"""
        return _digital_swig1.header_payload_demux_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_header_payload_demux_sptr

    def make(self, *args, **kwargs) -> "gr::digital::header_payload_demux::sptr":
        r"""make(header_payload_demux_sptr self, int const header_len, int const items_per_symbol=1, int const guard_interval=0, std::string const & length_tag_key="frame_len", std::string const & trigger_tag_key="", bool const output_symbols=False, size_t const itemsize=sizeof(gr_complex), std::string const & timing_tag_key="", double const samp_rate=1.0, std::vector< std::string,std::allocator< std::string > > const & special_tags=std::vector< std::string >(), size_t const header_padding=0) -> header_payload_demux_sptr"""
        return _digital_swig1.header_payload_demux_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(header_payload_demux_sptr self) -> unsigned int"""
        return _digital_swig1.header_payload_demux_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(header_payload_demux_sptr self, int which, int delay)
        declare_sample_delay(header_payload_demux_sptr self, unsigned int delay)
        """
        return _digital_swig1.header_payload_demux_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(header_payload_demux_sptr self, int which) -> unsigned int"""
        return _digital_swig1.header_payload_demux_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(header_payload_demux_sptr self, int multiple)"""
        return _digital_swig1.header_payload_demux_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(header_payload_demux_sptr self) -> double"""
        return _digital_swig1.header_payload_demux_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(header_payload_demux_sptr self) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(header_payload_demux_sptr self) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(header_payload_demux_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(header_payload_demux_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(header_payload_demux_sptr self, std::string level)"""
        return _digital_swig1.header_payload_demux_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(header_payload_demux_sptr self, int m)"""
        return _digital_swig1.header_payload_demux_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(header_payload_demux_sptr self)"""
        return _digital_swig1.header_payload_demux_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(header_payload_demux_sptr self, int m)"""
        return _digital_swig1.header_payload_demux_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(header_payload_demux_sptr self, int i) -> long"""
        return _digital_swig1.header_payload_demux_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(header_payload_demux_sptr self, long max_output_buffer)
        set_max_output_buffer(header_payload_demux_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.header_payload_demux_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(header_payload_demux_sptr self, int i) -> long"""
        return _digital_swig1.header_payload_demux_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(header_payload_demux_sptr self, long min_output_buffer)
        set_min_output_buffer(header_payload_demux_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.header_payload_demux_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(header_payload_demux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.header_payload_demux_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(header_payload_demux_sptr self)"""
        return _digital_swig1.header_payload_demux_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(header_payload_demux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.header_payload_demux_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(header_payload_demux_sptr self, int priority) -> int"""
        return _digital_swig1.header_payload_demux_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(header_payload_demux_sptr self) -> io_signature_sptr"""
        return _digital_swig1.header_payload_demux_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(header_payload_demux_sptr self) -> io_signature_sptr"""
        return _digital_swig1.header_payload_demux_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(header_payload_demux_sptr self) -> long"""
        return _digital_swig1.header_payload_demux_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(header_payload_demux_sptr self) -> basic_block_sptr"""
        return _digital_swig1.header_payload_demux_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(header_payload_demux_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(header_payload_demux_sptr self, std::string name)"""
        return _digital_swig1.header_payload_demux_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(header_payload_demux_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.header_payload_demux_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(header_payload_demux_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(header_payload_demux_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(header_payload_demux_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_subscribers(self, which_port)

# Register header_payload_demux_sptr in _digital_swig1:
_digital_swig1.header_payload_demux_sptr_swigregister(header_payload_demux_sptr)


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

class kurtotic_equalizer_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::kurtotic_equalizer_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__(kurtotic_equalizer_cc_sptr self) -> kurtotic_equalizer_cc_sptr
        __init__(kurtotic_equalizer_cc_sptr self, kurtotic_equalizer_cc p) -> kurtotic_equalizer_cc_sptr
        """
        _digital_swig1.kurtotic_equalizer_cc_sptr_swiginit(self, _digital_swig1.new_kurtotic_equalizer_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::kurtotic_equalizer_cc *":
        r"""__deref__(kurtotic_equalizer_cc_sptr self) -> kurtotic_equalizer_cc"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_kurtotic_equalizer_cc_sptr

    def make(self, num_taps: "int", mu: "float") -> "gr::digital::kurtotic_equalizer_cc::sptr":
        r"""make(kurtotic_equalizer_cc_sptr self, int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_make(self, num_taps, mu)

    def gain(self) -> "float":
        r"""gain(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(kurtotic_equalizer_cc_sptr self, float mu)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_gain(self, mu)

    def history(self) -> "unsigned int":
        r"""history(kurtotic_equalizer_cc_sptr self) -> unsigned int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(kurtotic_equalizer_cc_sptr self, int which, int delay)
        declare_sample_delay(kurtotic_equalizer_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(kurtotic_equalizer_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(kurtotic_equalizer_cc_sptr self, int multiple)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(kurtotic_equalizer_cc_sptr self) -> double"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(kurtotic_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(kurtotic_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(kurtotic_equalizer_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(kurtotic_equalizer_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(kurtotic_equalizer_cc_sptr self, std::string level)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(kurtotic_equalizer_cc_sptr self, int m)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(kurtotic_equalizer_cc_sptr self)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(kurtotic_equalizer_cc_sptr self, int m)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(kurtotic_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(kurtotic_equalizer_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(kurtotic_equalizer_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(kurtotic_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(kurtotic_equalizer_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(kurtotic_equalizer_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(kurtotic_equalizer_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(kurtotic_equalizer_cc_sptr self)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(kurtotic_equalizer_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(kurtotic_equalizer_cc_sptr self, int priority) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(kurtotic_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(kurtotic_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(kurtotic_equalizer_cc_sptr self) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(kurtotic_equalizer_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(kurtotic_equalizer_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(kurtotic_equalizer_cc_sptr self, std::string name)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(kurtotic_equalizer_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(kurtotic_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(kurtotic_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(kurtotic_equalizer_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_subscribers(self, which_port)

# Register kurtotic_equalizer_cc_sptr in _digital_swig1:
_digital_swig1.kurtotic_equalizer_cc_sptr_swigregister(kurtotic_equalizer_cc_sptr)


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

class map_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::map_bb > class."""

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

    def __init__(self, *args):
        r"""
        __init__(map_bb_sptr self) -> map_bb_sptr
        __init__(map_bb_sptr self, map_bb p) -> map_bb_sptr
        """
        _digital_swig1.map_bb_sptr_swiginit(self, _digital_swig1.new_map_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::map_bb *":
        r"""__deref__(map_bb_sptr self) -> map_bb"""
        return _digital_swig1.map_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_map_bb_sptr

    def make(self, map: "std::vector< int,std::allocator< int > > const &") -> "gr::digital::map_bb::sptr":
        r"""make(map_bb_sptr self, std::vector< int,std::allocator< int > > const & map) -> map_bb_sptr"""
        return _digital_swig1.map_bb_sptr_make(self, map)

    def set_map(self, map: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_map(map_bb_sptr self, std::vector< int,std::allocator< int > > const & map)"""
        return _digital_swig1.map_bb_sptr_set_map(self, map)

    def map(self) -> "std::vector< int,std::allocator< int > >":
        r"""map(map_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.map_bb_sptr_map(self)

    def history(self) -> "unsigned int":
        r"""history(map_bb_sptr self) -> unsigned int"""
        return _digital_swig1.map_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(map_bb_sptr self, int which, int delay)
        declare_sample_delay(map_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.map_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(map_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.map_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(map_bb_sptr self, int multiple)"""
        return _digital_swig1.map_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(map_bb_sptr self) -> double"""
        return _digital_swig1.map_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(map_bb_sptr self) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(map_bb_sptr self) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(map_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(map_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(map_bb_sptr self, std::string level)"""
        return _digital_swig1.map_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(map_bb_sptr self, int m)"""
        return _digital_swig1.map_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(map_bb_sptr self)"""
        return _digital_swig1.map_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(map_bb_sptr self, int m)"""
        return _digital_swig1.map_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(map_bb_sptr self, int i) -> long"""
        return _digital_swig1.map_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(map_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(map_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.map_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(map_bb_sptr self, int i) -> long"""
        return _digital_swig1.map_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(map_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(map_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.map_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(map_bb_sptr self, int which) -> float
        pc_input_buffers_full(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(map_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(map_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(map_bb_sptr self, int which) -> float
        pc_output_buffers_full(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(map_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(map_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(map_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.map_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(map_bb_sptr self)"""
        return _digital_swig1.map_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(map_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.map_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(map_bb_sptr self, int priority) -> int"""
        return _digital_swig1.map_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(map_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.map_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(map_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.map_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(map_bb_sptr self) -> long"""
        return _digital_swig1.map_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(map_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.map_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(map_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.map_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(map_bb_sptr self, std::string name)"""
        return _digital_swig1.map_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(map_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.map_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(map_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.map_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(map_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.map_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(map_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.map_bb_sptr_message_subscribers(self, which_port)

# Register map_bb_sptr in _digital_swig1:
_digital_swig1.map_bb_sptr_swigregister(map_bb_sptr)


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

class msk_timing_recovery_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::msk_timing_recovery_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__(msk_timing_recovery_cc_sptr self) -> msk_timing_recovery_cc_sptr
        __init__(msk_timing_recovery_cc_sptr self, msk_timing_recovery_cc p) -> msk_timing_recovery_cc_sptr
        """
        _digital_swig1.msk_timing_recovery_cc_sptr_swiginit(self, _digital_swig1.new_msk_timing_recovery_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::msk_timing_recovery_cc *":
        r"""__deref__(msk_timing_recovery_cc_sptr self) -> msk_timing_recovery_cc"""
        return _digital_swig1.msk_timing_recovery_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig1.delete_msk_timing_recovery_cc_sptr

    def make(self, sps: "float", gain: "float", limit: "float", osps: "int") -> "gr::digital::msk_timing_recovery_cc::sptr":
        r"""make(msk_timing_recovery_cc_sptr self, float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_make(self, sps, gain, limit, osps)

    def set_gain(self, gain: "float") -> "void":
        r"""set_gain(msk_timing_recovery_cc_sptr self, float gain)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_gain(self, gain)

    def get_gain(self) -> "float":
        r"""get_gain(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_gain(self)

    def set_limit(self, limit: "float") -> "void":
        r"""set_limit(msk_timing_recovery_cc_sptr self, float limit)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_limit(self, limit)

    def get_limit(self) -> "float":
        r"""get_limit(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_limit(self)

    def set_sps(self, sps: "float") -> "void":
        r"""set_sps(msk_timing_recovery_cc_sptr self, float sps)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_sps(self, sps)

    def get_sps(self) -> "float":
        r"""get_sps(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_sps(self)

    def history(self) -> "unsigned int":
        r"""history(msk_timing_recovery_cc_sptr self) -> unsigned int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(msk_timing_recovery_cc_sptr self, int which, int delay)
        declare_sample_delay(msk_timing_recovery_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(msk_timing_recovery_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(msk_timing_recovery_cc_sptr self, int multiple)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(msk_timing_recovery_cc_sptr self) -> double"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(msk_timing_recovery_cc_sptr self) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(msk_timing_recovery_cc_sptr self) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(msk_timing_recovery_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(msk_timing_recovery_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(msk_timing_recovery_cc_sptr self, std::string level)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(msk_timing_recovery_cc_sptr self)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(msk_timing_recovery_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(msk_timing_recovery_cc_sptr self)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(msk_timing_recovery_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(msk_timing_recovery_cc_sptr self, int priority) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(msk_timing_recovery_cc_sptr self) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(msk_timing_recovery_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(msk_timing_recovery_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(msk_timing_recovery_cc_sptr self, std::string name)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(msk_timing_recovery_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(msk_timing_recovery_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(msk_timing_recovery_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(msk_timing_recovery_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_subscribers(self, which_port)

# Register msk_timing_recovery_cc_sptr in _digital_swig1:
_digital_swig1.msk_timing_recovery_cc_sptr_swigregister(msk_timing_recovery_cc_sptr)


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



