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

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_swig0.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_swig0.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_swig0.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_swig0.high_res_timer_epoch()
class cpm(object):
    r"""Proxy of C++ gr::analog::cpm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LRC = _digital_swig0.cpm_LRC
    
    LSRC = _digital_swig0.cpm_LSRC
    
    LREC = _digital_swig0.cpm_LREC
    
    TFM = _digital_swig0.cpm_TFM
    
    GAUSSIAN = _digital_swig0.cpm_GAUSSIAN
    
    GENERIC = _digital_swig0.cpm_GENERIC
    

    @staticmethod
    def phase_response(type: "gr::analog::cpm::cpm_type", samples_per_sym: "unsigned int", L: "unsigned int", beta: "double"=0.3) -> "std::vector< float,std::allocator< float > >":
        r"""phase_response(gr::analog::cpm::cpm_type type, unsigned int samples_per_sym, unsigned int L, double beta=0.3) -> pmt_vector_float"""
        return _digital_swig0.cpm_phase_response(type, samples_per_sym, L, beta)

    def __init__(self):
        r"""__init__(cpm self) -> cpm"""
        _digital_swig0.cpm_swiginit(self, _digital_swig0.new_cpm())
    __swig_destroy__ = _digital_swig0.delete_cpm

# Register cpm in _digital_swig0:
_digital_swig0.cpm_swigregister(cpm)

def cpm_phase_response(type: "gr::analog::cpm::cpm_type", samples_per_sym: "unsigned int", L: "unsigned int", beta: "double"=0.3) -> "std::vector< float,std::allocator< float > >":
    r"""cpm_phase_response(gr::analog::cpm::cpm_type type, unsigned int samples_per_sym, unsigned int L, double beta=0.3) -> pmt_vector_float"""
    return _digital_swig0.cpm_phase_response(type, samples_per_sym, L, beta)

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_swig0.control_loop_swiginit(self, _digital_swig0.new_control_loop(*args))
    __swig_destroy__ = _digital_swig0.delete_control_loop

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

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

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

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

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(control_loop self, float bw)"""
        return _digital_swig0.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_swig0.control_loop_set_damping_factor(self, df)

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

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

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

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(control_loop self, float phase)"""
        return _digital_swig0.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_swig0.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_swig0.control_loop_set_min_freq(self, freq)

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

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

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

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

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

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

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

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

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


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

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

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

    @staticmethod
    def make() -> "gr::digital::binary_slicer_fb::sptr":
        r"""make() -> binary_slicer_fb_sptr"""
        return _digital_swig0.binary_slicer_fb_make()
    __swig_destroy__ = _digital_swig0.delete_binary_slicer_fb

# Register binary_slicer_fb in _digital_swig0:
_digital_swig0.binary_slicer_fb_swigregister(binary_slicer_fb)
cvar = _digital_swig0.cvar

def binary_slicer_fb_make() -> "gr::digital::binary_slicer_fb::sptr":
    r"""binary_slicer_fb_make() -> binary_slicer_fb_sptr"""
    return _digital_swig0.binary_slicer_fb_make()

class cma_equalizer_cc(object):
    r"""Proxy of C++ gr::digital::cma_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", modulus: "float", mu: "float", sps: "int") -> "gr::digital::cma_equalizer_cc::sptr":
        r"""make(int num_taps, float modulus, float mu, int sps) -> cma_equalizer_cc_sptr"""
        return _digital_swig0.cma_equalizer_cc_make(num_taps, modulus, mu, sps)

    def set_taps(self, taps: "pmt_vector_cfloat") -> "void":
        r"""set_taps(cma_equalizer_cc self, pmt_vector_cfloat taps)"""
        return _digital_swig0.cma_equalizer_cc_set_taps(self, taps)

    def taps(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""taps(cma_equalizer_cc self) -> pmt_vector_cfloat"""
        return _digital_swig0.cma_equalizer_cc_taps(self)

    def gain(self) -> "float":
        r"""gain(cma_equalizer_cc self) -> float"""
        return _digital_swig0.cma_equalizer_cc_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(cma_equalizer_cc self, float mu)"""
        return _digital_swig0.cma_equalizer_cc_set_gain(self, mu)

    def modulus(self) -> "float":
        r"""modulus(cma_equalizer_cc self) -> float"""
        return _digital_swig0.cma_equalizer_cc_modulus(self)

    def set_modulus(self, mod: "float") -> "void":
        r"""set_modulus(cma_equalizer_cc self, float mod)"""
        return _digital_swig0.cma_equalizer_cc_set_modulus(self, mod)
    __swig_destroy__ = _digital_swig0.delete_cma_equalizer_cc

# Register cma_equalizer_cc in _digital_swig0:
_digital_swig0.cma_equalizer_cc_swigregister(cma_equalizer_cc)

def cma_equalizer_cc_make(num_taps: "int", modulus: "float", mu: "float", sps: "int") -> "gr::digital::cma_equalizer_cc::sptr":
    r"""cma_equalizer_cc_make(int num_taps, float modulus, float mu, int sps) -> cma_equalizer_cc_sptr"""
    return _digital_swig0.cma_equalizer_cc_make(num_taps, modulus, mu, sps)

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

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

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

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation self) -> bool"""
        return _digital_swig0.constellation_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation self, bool a)"""
        return _digital_swig0.constellation_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation self) -> unsigned int"""
        return _digital_swig0.constellation_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation self) -> unsigned int"""
        return _digital_swig0.constellation_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation self) -> unsigned int"""
        return _digital_swig0.constellation_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation self) -> unsigned int"""
        return _digital_swig0.constellation_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation self) -> constellation_sptr"""
        return _digital_swig0.constellation_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation self) -> bool"""
        return _digital_swig0.constellation_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_soft_decision_maker(self, sample)

# Register constellation in _digital_swig0:
_digital_swig0.constellation_swigregister(constellation)

class constellation_calcdist(constellation):
    r"""Proxy of C++ gr::digital::constellation_calcdist 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(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _digital_swig0.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)
    __swig_destroy__ = _digital_swig0.delete_constellation_calcdist

# Register constellation_calcdist in _digital_swig0:
_digital_swig0.constellation_calcdist_swigregister(constellation_calcdist)

def constellation_calcdist_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
    r"""constellation_calcdist_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
    return _digital_swig0.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

class constellation_sector(constellation):
    r"""Proxy of C++ gr::digital::constellation_sector class."""

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

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

# Register constellation_sector in _digital_swig0:
_digital_swig0.constellation_sector_swigregister(constellation_sector)

class constellation_rect(constellation_sector):
    r"""Proxy of C++ gr::digital::constellation_rect 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(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _digital_swig0.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)
    __swig_destroy__ = _digital_swig0.delete_constellation_rect

# Register constellation_rect in _digital_swig0:
_digital_swig0.constellation_rect_swigregister(constellation_rect)

def constellation_rect_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
    r"""constellation_rect_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
    return _digital_swig0.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

class constellation_expl_rect(constellation_rect):
    r"""Proxy of C++ gr::digital::constellation_expl_rect 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(constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
        r"""make(pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _digital_swig0.constellation_expl_rect_make(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)
    __swig_destroy__ = _digital_swig0.delete_constellation_expl_rect

# Register constellation_expl_rect in _digital_swig0:
_digital_swig0.constellation_expl_rect_swigregister(constellation_expl_rect)

def constellation_expl_rect_make(constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
    r"""constellation_expl_rect_make(pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
    return _digital_swig0.constellation_expl_rect_make(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)

class constellation_psk(constellation_sector):
    r"""Proxy of C++ gr::digital::constellation_psk 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(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _digital_swig0.constellation_psk_make(constell, pre_diff_code, n_sectors)
    __swig_destroy__ = _digital_swig0.delete_constellation_psk

# Register constellation_psk in _digital_swig0:
_digital_swig0.constellation_psk_swigregister(constellation_psk)

def constellation_psk_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
    r"""constellation_psk_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
    return _digital_swig0.constellation_psk_make(constell, pre_diff_code, n_sectors)

class constellation_bpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_bpsk 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::constellation_bpsk::sptr":
        r"""make() -> constellation_bpsk_sptr"""
        return _digital_swig0.constellation_bpsk_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_bpsk

# Register constellation_bpsk in _digital_swig0:
_digital_swig0.constellation_bpsk_swigregister(constellation_bpsk)

def constellation_bpsk_make() -> "gr::digital::constellation_bpsk::sptr":
    r"""constellation_bpsk_make() -> constellation_bpsk_sptr"""
    return _digital_swig0.constellation_bpsk_make()

class constellation_qpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_qpsk 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::constellation_qpsk::sptr":
        r"""make() -> constellation_qpsk_sptr"""
        return _digital_swig0.constellation_qpsk_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_qpsk

# Register constellation_qpsk in _digital_swig0:
_digital_swig0.constellation_qpsk_swigregister(constellation_qpsk)

def constellation_qpsk_make() -> "gr::digital::constellation_qpsk::sptr":
    r"""constellation_qpsk_make() -> constellation_qpsk_sptr"""
    return _digital_swig0.constellation_qpsk_make()

class constellation_dqpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_dqpsk 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::constellation_dqpsk::sptr":
        r"""make() -> constellation_dqpsk_sptr"""
        return _digital_swig0.constellation_dqpsk_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_dqpsk

# Register constellation_dqpsk in _digital_swig0:
_digital_swig0.constellation_dqpsk_swigregister(constellation_dqpsk)

def constellation_dqpsk_make() -> "gr::digital::constellation_dqpsk::sptr":
    r"""constellation_dqpsk_make() -> constellation_dqpsk_sptr"""
    return _digital_swig0.constellation_dqpsk_make()

class constellation_8psk(constellation):
    r"""Proxy of C++ gr::digital::constellation_8psk 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::constellation_8psk::sptr":
        r"""make() -> constellation_8psk_sptr"""
        return _digital_swig0.constellation_8psk_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_8psk

# Register constellation_8psk in _digital_swig0:
_digital_swig0.constellation_8psk_swigregister(constellation_8psk)

def constellation_8psk_make() -> "gr::digital::constellation_8psk::sptr":
    r"""constellation_8psk_make() -> constellation_8psk_sptr"""
    return _digital_swig0.constellation_8psk_make()

class constellation_8psk_natural(constellation):
    r"""Proxy of C++ gr::digital::constellation_8psk_natural 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::constellation_8psk_natural::sptr":
        r"""make() -> constellation_8psk_natural_sptr"""
        return _digital_swig0.constellation_8psk_natural_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_8psk_natural

# Register constellation_8psk_natural in _digital_swig0:
_digital_swig0.constellation_8psk_natural_swigregister(constellation_8psk_natural)

def constellation_8psk_natural_make() -> "gr::digital::constellation_8psk_natural::sptr":
    r"""constellation_8psk_natural_make() -> constellation_8psk_natural_sptr"""
    return _digital_swig0.constellation_8psk_natural_make()

class constellation_16qam(constellation):
    r"""Proxy of C++ gr::digital::constellation_16qam 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::constellation_16qam::sptr":
        r"""make() -> constellation_16qam_sptr"""
        return _digital_swig0.constellation_16qam_make()
    __swig_destroy__ = _digital_swig0.delete_constellation_16qam

# Register constellation_16qam in _digital_swig0:
_digital_swig0.constellation_16qam_swigregister(constellation_16qam)

def constellation_16qam_make() -> "gr::digital::constellation_16qam::sptr":
    r"""constellation_16qam_make() -> constellation_16qam_sptr"""
    return _digital_swig0.constellation_16qam_make()

class constellation_decoder_cb(object):
    r"""Proxy of C++ gr::digital::constellation_decoder_cb 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(constellation: "constellation_sptr") -> "gr::digital::constellation_decoder_cb::sptr":
        r"""make(constellation_sptr constellation) -> constellation_decoder_cb_sptr"""
        return _digital_swig0.constellation_decoder_cb_make(constellation)
    __swig_destroy__ = _digital_swig0.delete_constellation_decoder_cb

# Register constellation_decoder_cb in _digital_swig0:
_digital_swig0.constellation_decoder_cb_swigregister(constellation_decoder_cb)

def constellation_decoder_cb_make(constellation: "constellation_sptr") -> "gr::digital::constellation_decoder_cb::sptr":
    r"""constellation_decoder_cb_make(constellation_sptr constellation) -> constellation_decoder_cb_sptr"""
    return _digital_swig0.constellation_decoder_cb_make(constellation)

class constellation_receiver_cb(control_loop):
    r"""Proxy of C++ gr::digital::constellation_receiver_cb 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(constellation: "constellation_sptr", loop_bw: "float", fmin: "float", fmax: "float") -> "gr::digital::constellation_receiver_cb::sptr":
        r"""make(constellation_sptr constellation, float loop_bw, float fmin, float fmax) -> constellation_receiver_cb_sptr"""
        return _digital_swig0.constellation_receiver_cb_make(constellation, loop_bw, fmin, fmax)

    def phase_error_tracking(self, phase_error: "float") -> "void":
        r"""phase_error_tracking(constellation_receiver_cb self, float phase_error)"""
        return _digital_swig0.constellation_receiver_cb_phase_error_tracking(self, phase_error)
    __swig_destroy__ = _digital_swig0.delete_constellation_receiver_cb

# Register constellation_receiver_cb in _digital_swig0:
_digital_swig0.constellation_receiver_cb_swigregister(constellation_receiver_cb)

def constellation_receiver_cb_make(constellation: "constellation_sptr", loop_bw: "float", fmin: "float", fmax: "float") -> "gr::digital::constellation_receiver_cb::sptr":
    r"""constellation_receiver_cb_make(constellation_sptr constellation, float loop_bw, float fmin, float fmax) -> constellation_receiver_cb_sptr"""
    return _digital_swig0.constellation_receiver_cb_make(constellation, loop_bw, fmin, fmax)

class constellation_soft_decoder_cf(object):
    r"""Proxy of C++ gr::digital::constellation_soft_decoder_cf 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(constellation: "constellation_sptr") -> "gr::digital::constellation_soft_decoder_cf::sptr":
        r"""make(constellation_sptr constellation) -> constellation_soft_decoder_cf_sptr"""
        return _digital_swig0.constellation_soft_decoder_cf_make(constellation)
    __swig_destroy__ = _digital_swig0.delete_constellation_soft_decoder_cf

# Register constellation_soft_decoder_cf in _digital_swig0:
_digital_swig0.constellation_soft_decoder_cf_swigregister(constellation_soft_decoder_cf)

def constellation_soft_decoder_cf_make(constellation: "constellation_sptr") -> "gr::digital::constellation_soft_decoder_cf::sptr":
    r"""constellation_soft_decoder_cf_make(constellation_sptr constellation) -> constellation_soft_decoder_cf_sptr"""
    return _digital_swig0.constellation_soft_decoder_cf_make(constellation)

THRESHOLD_DYNAMIC = _digital_swig0.THRESHOLD_DYNAMIC

THRESHOLD_ABSOLUTE = _digital_swig0.THRESHOLD_ABSOLUTE

class corr_est_cc(object):
    r"""Proxy of C++ gr::digital::corr_est_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(*args, **kwargs) -> "gr::digital::corr_est_cc::sptr":
        r"""make(pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9, gr::digital::tm_type threshold_method=THRESHOLD_ABSOLUTE) -> corr_est_cc_sptr"""
        return _digital_swig0.corr_est_cc_make(*args, **kwargs)

    def symbols(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""symbols(corr_est_cc self) -> pmt_vector_cfloat"""
        return _digital_swig0.corr_est_cc_symbols(self)

    def set_symbols(self, symbols: "pmt_vector_cfloat") -> "void":
        r"""set_symbols(corr_est_cc self, pmt_vector_cfloat symbols)"""
        return _digital_swig0.corr_est_cc_set_symbols(self, symbols)

    def mark_delay(self) -> "unsigned int":
        r"""mark_delay(corr_est_cc self) -> unsigned int"""
        return _digital_swig0.corr_est_cc_mark_delay(self)

    def set_mark_delay(self, mark_delay: "unsigned int") -> "void":
        r"""set_mark_delay(corr_est_cc self, unsigned int mark_delay)"""
        return _digital_swig0.corr_est_cc_set_mark_delay(self, mark_delay)

    def threshold(self) -> "float":
        r"""threshold(corr_est_cc self) -> float"""
        return _digital_swig0.corr_est_cc_threshold(self)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(corr_est_cc self, float threshold)"""
        return _digital_swig0.corr_est_cc_set_threshold(self, threshold)
    __swig_destroy__ = _digital_swig0.delete_corr_est_cc

# Register corr_est_cc in _digital_swig0:
_digital_swig0.corr_est_cc_swigregister(corr_est_cc)

def corr_est_cc_make(*args, **kwargs) -> "gr::digital::corr_est_cc::sptr":
    r"""corr_est_cc_make(pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9, gr::digital::tm_type threshold_method=THRESHOLD_ABSOLUTE) -> corr_est_cc_sptr"""
    return _digital_swig0.corr_est_cc_make(*args, **kwargs)

class correlate_access_code_bb(object):
    r"""Proxy of C++ gr::digital::correlate_access_code_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(access_code: "std::string const &", threshold: "int") -> "gr::digital::correlate_access_code_bb::sptr":
        r"""make(std::string const & access_code, int threshold) -> correlate_access_code_bb_sptr"""
        return _digital_swig0.correlate_access_code_bb_make(access_code, threshold)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_bb self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_bb_set_access_code(self, access_code)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_bb

# Register correlate_access_code_bb in _digital_swig0:
_digital_swig0.correlate_access_code_bb_swigregister(correlate_access_code_bb)

def correlate_access_code_bb_make(access_code: "std::string const &", threshold: "int") -> "gr::digital::correlate_access_code_bb::sptr":
    r"""correlate_access_code_bb_make(std::string const & access_code, int threshold) -> correlate_access_code_bb_sptr"""
    return _digital_swig0.correlate_access_code_bb_make(access_code, threshold)

class correlate_access_code_tag_bb(object):
    r"""Proxy of C++ gr::digital::correlate_access_code_tag_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(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_bb::sptr":
        r"""make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_bb_sptr"""
        return _digital_swig0.correlate_access_code_tag_bb_make(access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_tag_bb self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_set_access_code(self, access_code)

    def set_threshold(self, threshold: "int") -> "void":
        r"""set_threshold(correlate_access_code_tag_bb self, int threshold)"""
        return _digital_swig0.correlate_access_code_tag_bb_set_threshold(self, threshold)

    def set_tagname(self, tagname: "std::string const &") -> "void":
        r"""set_tagname(correlate_access_code_tag_bb self, std::string const & tagname)"""
        return _digital_swig0.correlate_access_code_tag_bb_set_tagname(self, tagname)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_tag_bb

# Register correlate_access_code_tag_bb in _digital_swig0:
_digital_swig0.correlate_access_code_tag_bb_swigregister(correlate_access_code_tag_bb)

def correlate_access_code_tag_bb_make(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_bb::sptr":
    r"""correlate_access_code_tag_bb_make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_bb_sptr"""
    return _digital_swig0.correlate_access_code_tag_bb_make(access_code, threshold, tag_name)

class correlate_access_code_tag_ff(object):
    r"""Proxy of C++ gr::digital::correlate_access_code_tag_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(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_ff::sptr":
        r"""make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_ff_sptr"""
        return _digital_swig0.correlate_access_code_tag_ff_make(access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_tag_ff self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_set_access_code(self, access_code)

    def set_threshold(self, threshold: "int") -> "void":
        r"""set_threshold(correlate_access_code_tag_ff self, int threshold)"""
        return _digital_swig0.correlate_access_code_tag_ff_set_threshold(self, threshold)

    def set_tagname(self, tagname: "std::string const &") -> "void":
        r"""set_tagname(correlate_access_code_tag_ff self, std::string const & tagname)"""
        return _digital_swig0.correlate_access_code_tag_ff_set_tagname(self, tagname)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_tag_ff

# Register correlate_access_code_tag_ff in _digital_swig0:
_digital_swig0.correlate_access_code_tag_ff_swigregister(correlate_access_code_tag_ff)

def correlate_access_code_tag_ff_make(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_ff::sptr":
    r"""correlate_access_code_tag_ff_make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_ff_sptr"""
    return _digital_swig0.correlate_access_code_tag_ff_make(access_code, threshold, tag_name)

class correlate_access_code_bb_ts(object):
    r"""Proxy of C++ gr::digital::correlate_access_code_bb_ts 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(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_bb_ts::sptr":
        r"""make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_bb_ts_sptr"""
        return _digital_swig0.correlate_access_code_bb_ts_make(access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_bb_ts self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(correlate_access_code_bb_ts self) -> unsigned long long"""
        return _digital_swig0.correlate_access_code_bb_ts_access_code(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_bb_ts

# Register correlate_access_code_bb_ts in _digital_swig0:
_digital_swig0.correlate_access_code_bb_ts_swigregister(correlate_access_code_bb_ts)

def correlate_access_code_bb_ts_make(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_bb_ts::sptr":
    r"""correlate_access_code_bb_ts_make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_bb_ts_sptr"""
    return _digital_swig0.correlate_access_code_bb_ts_make(access_code, threshold, tag_name)

class correlate_access_code_ff_ts(object):
    r"""Proxy of C++ gr::digital::correlate_access_code_ff_ts 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(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_ff_ts::sptr":
        r"""make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_ff_ts_sptr"""
        return _digital_swig0.correlate_access_code_ff_ts_make(access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_ff_ts self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(correlate_access_code_ff_ts self) -> unsigned long long"""
        return _digital_swig0.correlate_access_code_ff_ts_access_code(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_ff_ts

# Register correlate_access_code_ff_ts in _digital_swig0:
_digital_swig0.correlate_access_code_ff_ts_swigregister(correlate_access_code_ff_ts)

def correlate_access_code_ff_ts_make(access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_ff_ts::sptr":
    r"""correlate_access_code_ff_ts_make(std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_ff_ts_sptr"""
    return _digital_swig0.correlate_access_code_ff_ts_make(access_code, threshold, tag_name)

class costas_loop_cc(control_loop):
    r"""Proxy of C++ gr::digital::costas_loop_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(loop_bw: "float", order: "int", use_snr: "bool"=False) -> "gr::digital::costas_loop_cc::sptr":
        r"""make(float loop_bw, int order, bool use_snr=False) -> costas_loop_cc_sptr"""
        return _digital_swig0.costas_loop_cc_make(loop_bw, order, use_snr)

    def error(self) -> "float":
        r"""error(costas_loop_cc self) -> float"""
        return _digital_swig0.costas_loop_cc_error(self)
    __swig_destroy__ = _digital_swig0.delete_costas_loop_cc

# Register costas_loop_cc in _digital_swig0:
_digital_swig0.costas_loop_cc_swigregister(costas_loop_cc)

def costas_loop_cc_make(loop_bw: "float", order: "int", use_snr: "bool"=False) -> "gr::digital::costas_loop_cc::sptr":
    r"""costas_loop_cc_make(float loop_bw, int order, bool use_snr=False) -> costas_loop_cc_sptr"""
    return _digital_swig0.costas_loop_cc_make(loop_bw, order, use_snr)

class cpmmod_bc(object):
    r"""Proxy of C++ gr::digital::cpmmod_bc 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(type: "gr::analog::cpm::cpm_type", h: "float", samples_per_sym: "int", L: "int", beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make(gr::analog::cpm::cpm_type type, float h, int samples_per_sym, int L, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.cpmmod_bc_make(type, h, samples_per_sym, L, beta)

    @staticmethod
    def make_gmskmod_bc(samples_per_sym: "int"=2, L: "int"=4, beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make_gmskmod_bc(int samples_per_sym=2, int L=4, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.cpmmod_bc_make_gmskmod_bc(samples_per_sym, L, beta)

    def taps(self) -> "std::vector< float,std::allocator< float > >":
        r"""taps(cpmmod_bc self) -> pmt_vector_float"""
        return _digital_swig0.cpmmod_bc_taps(self)

    def type(self) -> "int":
        r"""type(cpmmod_bc self) -> int"""
        return _digital_swig0.cpmmod_bc_type(self)

    def index(self) -> "float":
        r"""index(cpmmod_bc self) -> float"""
        return _digital_swig0.cpmmod_bc_index(self)

    def samples_per_sym(self) -> "int":
        r"""samples_per_sym(cpmmod_bc self) -> int"""
        return _digital_swig0.cpmmod_bc_samples_per_sym(self)

    def length(self) -> "int":
        r"""length(cpmmod_bc self) -> int"""
        return _digital_swig0.cpmmod_bc_length(self)

    def beta(self) -> "double":
        r"""beta(cpmmod_bc self) -> double"""
        return _digital_swig0.cpmmod_bc_beta(self)
    __swig_destroy__ = _digital_swig0.delete_cpmmod_bc

# Register cpmmod_bc in _digital_swig0:
_digital_swig0.cpmmod_bc_swigregister(cpmmod_bc)

def cpmmod_bc_make(type: "gr::analog::cpm::cpm_type", h: "float", samples_per_sym: "int", L: "int", beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
    r"""cpmmod_bc_make(gr::analog::cpm::cpm_type type, float h, int samples_per_sym, int L, double beta=0.3) -> cpmmod_bc_sptr"""
    return _digital_swig0.cpmmod_bc_make(type, h, samples_per_sym, L, beta)

def cpmmod_bc_make_gmskmod_bc(samples_per_sym: "int"=2, L: "int"=4, beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
    r"""cpmmod_bc_make_gmskmod_bc(int samples_per_sym=2, int L=4, double beta=0.3) -> cpmmod_bc_sptr"""
    return _digital_swig0.cpmmod_bc_make_gmskmod_bc(samples_per_sym, L, beta)


def update_crc32(*args) -> "unsigned int":
    r"""
    update_crc32(unsigned int crc, unsigned char const * buf, size_t len) -> unsigned int
    update_crc32(unsigned int crc, std::string const buf) -> unsigned int
    """
    return _digital_swig0.update_crc32(*args)

def crc32(*args) -> "unsigned int":
    r"""
    crc32(unsigned char const * buf, size_t len) -> unsigned int
    crc32(std::string const buf) -> unsigned int
    """
    return _digital_swig0.crc32(*args)
class crc32_bb(object):
    r"""Proxy of C++ gr::digital::crc32_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(*args, **kwargs) -> "gr::digital::crc32_bb::sptr":
        r"""make(bool check=False, std::string const & lengthtagname="packet_len", bool packed=True) -> crc32_bb_sptr"""
        return _digital_swig0.crc32_bb_make(*args, **kwargs)
    __swig_destroy__ = _digital_swig0.delete_crc32_bb

# Register crc32_bb in _digital_swig0:
_digital_swig0.crc32_bb_swigregister(crc32_bb)

def crc32_bb_make(*args, **kwargs) -> "gr::digital::crc32_bb::sptr":
    r"""crc32_bb_make(bool check=False, std::string const & lengthtagname="packet_len", bool packed=True) -> crc32_bb_sptr"""
    return _digital_swig0.crc32_bb_make(*args, **kwargs)

class crc32_async_bb(object):
    r"""Proxy of C++ gr::digital::crc32_async_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(check: "bool"=False) -> "gr::digital::crc32_async_bb::sptr":
        r"""make(bool check=False) -> crc32_async_bb_sptr"""
        return _digital_swig0.crc32_async_bb_make(check)
    __swig_destroy__ = _digital_swig0.delete_crc32_async_bb

# Register crc32_async_bb in _digital_swig0:
_digital_swig0.crc32_async_bb_swigregister(crc32_async_bb)

def crc32_async_bb_make(check: "bool"=False) -> "gr::digital::crc32_async_bb::sptr":
    r"""crc32_async_bb_make(bool check=False) -> crc32_async_bb_sptr"""
    return _digital_swig0.crc32_async_bb_make(check)

class descrambler_bb(object):
    r"""Proxy of C++ gr::digital::descrambler_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(mask: "int", seed: "int", len: "int") -> "gr::digital::descrambler_bb::sptr":
        r"""make(int mask, int seed, int len) -> descrambler_bb_sptr"""
        return _digital_swig0.descrambler_bb_make(mask, seed, len)
    __swig_destroy__ = _digital_swig0.delete_descrambler_bb

# Register descrambler_bb in _digital_swig0:
_digital_swig0.descrambler_bb_swigregister(descrambler_bb)

def descrambler_bb_make(mask: "int", seed: "int", len: "int") -> "gr::digital::descrambler_bb::sptr":
    r"""descrambler_bb_make(int mask, int seed, int len) -> descrambler_bb_sptr"""
    return _digital_swig0.descrambler_bb_make(mask, seed, len)

class lms_dd_equalizer_cc(object):
    r"""Proxy of C++ gr::digital::lms_dd_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", sps: "int", cnst: "constellation_sptr") -> "gr::digital::lms_dd_equalizer_cc::sptr":
        r"""make(int num_taps, float mu, int sps, constellation_sptr cnst) -> lms_dd_equalizer_cc_sptr"""
        return _digital_swig0.lms_dd_equalizer_cc_make(num_taps, mu, sps, cnst)

    def set_taps(self, taps: "pmt_vector_cfloat") -> "void":
        r"""set_taps(lms_dd_equalizer_cc self, pmt_vector_cfloat taps)"""
        return _digital_swig0.lms_dd_equalizer_cc_set_taps(self, taps)

    def taps(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""taps(lms_dd_equalizer_cc self) -> pmt_vector_cfloat"""
        return _digital_swig0.lms_dd_equalizer_cc_taps(self)

    def gain(self) -> "float":
        r"""gain(lms_dd_equalizer_cc self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(lms_dd_equalizer_cc self, float mu)"""
        return _digital_swig0.lms_dd_equalizer_cc_set_gain(self, mu)
    __swig_destroy__ = _digital_swig0.delete_lms_dd_equalizer_cc

# Register lms_dd_equalizer_cc in _digital_swig0:
_digital_swig0.lms_dd_equalizer_cc_swigregister(lms_dd_equalizer_cc)

def lms_dd_equalizer_cc_make(num_taps: "int", mu: "float", sps: "int", cnst: "constellation_sptr") -> "gr::digital::lms_dd_equalizer_cc::sptr":
    r"""lms_dd_equalizer_cc_make(int num_taps, float mu, int sps, constellation_sptr cnst) -> lms_dd_equalizer_cc_sptr"""
    return _digital_swig0.lms_dd_equalizer_cc_make(num_taps, mu, sps, cnst)

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

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

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

    def len_tag_key(self) -> "std::string":
        r"""len_tag_key(ofdm_carrier_allocator_cvc self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_len_tag_key(self)

    def fft_len(self) -> "int const":
        r"""fft_len(ofdm_carrier_allocator_cvc self) -> int const"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_fft_len(self)

    def occupied_carriers(self) -> "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >":
        r"""occupied_carriers(ofdm_carrier_allocator_cvc self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_occupied_carriers(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::ofdm_carrier_allocator_cvc::sptr":
        r"""make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers, gr_vector_vector_complexf pilot_symbols, gr_vector_vector_complexf sync_words, std::string const & len_tag_key="packet_len", bool const output_is_shifted=True) -> ofdm_carrier_allocator_cvc_sptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_make(*args, **kwargs)
    __swig_destroy__ = _digital_swig0.delete_ofdm_carrier_allocator_cvc

# Register ofdm_carrier_allocator_cvc in _digital_swig0:
_digital_swig0.ofdm_carrier_allocator_cvc_swigregister(ofdm_carrier_allocator_cvc)

def ofdm_carrier_allocator_cvc_make(*args, **kwargs) -> "gr::digital::ofdm_carrier_allocator_cvc::sptr":
    r"""ofdm_carrier_allocator_cvc_make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers, gr_vector_vector_complexf pilot_symbols, gr_vector_vector_complexf sync_words, std::string const & len_tag_key="packet_len", bool const output_is_shifted=True) -> ofdm_carrier_allocator_cvc_sptr"""
    return _digital_swig0.ofdm_carrier_allocator_cvc_make(*args, **kwargs)

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

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

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

    @staticmethod
    def make(sync_symbol1: "pmt_vector_cfloat", sync_symbol2: "pmt_vector_cfloat", n_data_symbols: "int", eq_noise_red_len: "int"=0, max_carr_offset: "int"=-1, force_one_sync_symbol: "bool"=False) -> "gr::digital::ofdm_chanest_vcvc::sptr":
        r"""make(pmt_vector_cfloat sync_symbol1, pmt_vector_cfloat sync_symbol2, int n_data_symbols, int eq_noise_red_len=0, int max_carr_offset=-1, bool force_one_sync_symbol=False) -> ofdm_chanest_vcvc_sptr"""
        return _digital_swig0.ofdm_chanest_vcvc_make(sync_symbol1, sync_symbol2, n_data_symbols, eq_noise_red_len, max_carr_offset, force_one_sync_symbol)
    __swig_destroy__ = _digital_swig0.delete_ofdm_chanest_vcvc

# Register ofdm_chanest_vcvc in _digital_swig0:
_digital_swig0.ofdm_chanest_vcvc_swigregister(ofdm_chanest_vcvc)

def ofdm_chanest_vcvc_make(sync_symbol1: "pmt_vector_cfloat", sync_symbol2: "pmt_vector_cfloat", n_data_symbols: "int", eq_noise_red_len: "int"=0, max_carr_offset: "int"=-1, force_one_sync_symbol: "bool"=False) -> "gr::digital::ofdm_chanest_vcvc::sptr":
    r"""ofdm_chanest_vcvc_make(pmt_vector_cfloat sync_symbol1, pmt_vector_cfloat sync_symbol2, int n_data_symbols, int eq_noise_red_len=0, int max_carr_offset=-1, bool force_one_sync_symbol=False) -> ofdm_chanest_vcvc_sptr"""
    return _digital_swig0.ofdm_chanest_vcvc_make(sync_symbol1, sync_symbol2, n_data_symbols, eq_noise_red_len, max_carr_offset, force_one_sync_symbol)

class ofdm_cyclic_prefixer(object):
    r"""Proxy of C++ gr::digital::ofdm_cyclic_prefixer 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::ofdm_cyclic_prefixer::sptr":
        r"""make(size_t input_size, size_t output_size, int rolloff_len=0, std::string const & len_tag_key="") -> ofdm_cyclic_prefixer_sptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_make(*args, **kwargs)
    __swig_destroy__ = _digital_swig0.delete_ofdm_cyclic_prefixer

# Register ofdm_cyclic_prefixer in _digital_swig0:
_digital_swig0.ofdm_cyclic_prefixer_swigregister(ofdm_cyclic_prefixer)

def ofdm_cyclic_prefixer_make(*args, **kwargs) -> "gr::digital::ofdm_cyclic_prefixer::sptr":
    r"""ofdm_cyclic_prefixer_make(size_t input_size, size_t output_size, int rolloff_len=0, std::string const & len_tag_key="") -> ofdm_cyclic_prefixer_sptr"""
    return _digital_swig0.ofdm_cyclic_prefixer_make(*args, **kwargs)

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

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

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

    def reset(self) -> "void":
        r"""reset(ofdm_equalizer_base self)"""
        return _digital_swig0.ofdm_equalizer_base_reset(self)

    def equalize(self, *args, **kwargs) -> "void":
        r"""equalize(ofdm_equalizer_base self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())"""
        return _digital_swig0.ofdm_equalizer_base_equalize(self, *args, **kwargs)

    def get_channel_state(self, taps: "pmt_vector_cfloat") -> "void":
        r"""get_channel_state(ofdm_equalizer_base self, pmt_vector_cfloat taps)"""
        return _digital_swig0.ofdm_equalizer_base_get_channel_state(self, taps)

    def fft_len(self) -> "int":
        r"""fft_len(ofdm_equalizer_base self) -> int"""
        return _digital_swig0.ofdm_equalizer_base_fft_len(self)

    def base(self) -> "gr::digital::ofdm_equalizer_base::sptr":
        r"""base(ofdm_equalizer_base self) -> ofdm_equalizer_base_sptr"""
        return _digital_swig0.ofdm_equalizer_base_base(self)

# Register ofdm_equalizer_base in _digital_swig0:
_digital_swig0.ofdm_equalizer_base_swigregister(ofdm_equalizer_base)

class ofdm_equalizer_1d_pilots(ofdm_equalizer_base):
    r"""Proxy of C++ gr::digital::ofdm_equalizer_1d_pilots class."""

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

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

# Register ofdm_equalizer_1d_pilots in _digital_swig0:
_digital_swig0.ofdm_equalizer_1d_pilots_swigregister(ofdm_equalizer_1d_pilots)

class ofdm_equalizer_simpledfe(ofdm_equalizer_1d_pilots):
    r"""Proxy of C++ gr::digital::ofdm_equalizer_simpledfe 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, **kwargs):
        r"""__init__(ofdm_equalizer_simpledfe self, int fft_len, constellation_sptr constellation, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=True) -> ofdm_equalizer_simpledfe"""
        _digital_swig0.ofdm_equalizer_simpledfe_swiginit(self, _digital_swig0.new_ofdm_equalizer_simpledfe(*args, **kwargs))
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_simpledfe

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::ofdm_equalizer_simpledfe::sptr":
        r"""make(int fft_len, constellation_sptr constellation, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=True) -> ofdm_equalizer_simpledfe_sptr"""
        return _digital_swig0.ofdm_equalizer_simpledfe_make(*args, **kwargs)

# Register ofdm_equalizer_simpledfe in _digital_swig0:
_digital_swig0.ofdm_equalizer_simpledfe_swigregister(ofdm_equalizer_simpledfe)

def ofdm_equalizer_simpledfe_make(*args, **kwargs) -> "gr::digital::ofdm_equalizer_simpledfe::sptr":
    r"""ofdm_equalizer_simpledfe_make(int fft_len, constellation_sptr constellation, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=True) -> ofdm_equalizer_simpledfe_sptr"""
    return _digital_swig0.ofdm_equalizer_simpledfe_make(*args, **kwargs)

class ofdm_equalizer_static(ofdm_equalizer_1d_pilots):
    r"""Proxy of C++ gr::digital::ofdm_equalizer_static 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, **kwargs):
        r"""__init__(ofdm_equalizer_static self, int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, bool input_is_shifted=True) -> ofdm_equalizer_static"""
        _digital_swig0.ofdm_equalizer_static_swiginit(self, _digital_swig0.new_ofdm_equalizer_static(*args, **kwargs))
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_static

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::ofdm_equalizer_static::sptr":
        r"""make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, bool input_is_shifted=True) -> ofdm_equalizer_static_sptr"""
        return _digital_swig0.ofdm_equalizer_static_make(*args, **kwargs)

# Register ofdm_equalizer_static in _digital_swig0:
_digital_swig0.ofdm_equalizer_static_swigregister(ofdm_equalizer_static)

def ofdm_equalizer_static_make(*args, **kwargs) -> "gr::digital::ofdm_equalizer_static::sptr":
    r"""ofdm_equalizer_static_make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, bool input_is_shifted=True) -> ofdm_equalizer_static_sptr"""
    return _digital_swig0.ofdm_equalizer_static_make(*args, **kwargs)

class ofdm_frame_equalizer_vcvc(object):
    r"""Proxy of C++ gr::digital::ofdm_frame_equalizer_vcvc 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::ofdm_frame_equalizer_vcvc::sptr":
        r"""make(ofdm_equalizer_base_sptr equalizer, int cp_len, std::string const & tsb_key="frame_len", bool propagate_channel_state=False, int fixed_frame_len=0) -> ofdm_frame_equalizer_vcvc_sptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_make(*args, **kwargs)
    __swig_destroy__ = _digital_swig0.delete_ofdm_frame_equalizer_vcvc

# Register ofdm_frame_equalizer_vcvc in _digital_swig0:
_digital_swig0.ofdm_frame_equalizer_vcvc_swigregister(ofdm_frame_equalizer_vcvc)

def ofdm_frame_equalizer_vcvc_make(*args, **kwargs) -> "gr::digital::ofdm_frame_equalizer_vcvc::sptr":
    r"""ofdm_frame_equalizer_vcvc_make(ofdm_equalizer_base_sptr equalizer, int cp_len, std::string const & tsb_key="frame_len", bool propagate_channel_state=False, int fixed_frame_len=0) -> ofdm_frame_equalizer_vcvc_sptr"""
    return _digital_swig0.ofdm_frame_equalizer_vcvc_make(*args, **kwargs)

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

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

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

    @staticmethod
    def make(*args) -> "gr::digital::ofdm_serializer_vcc::sptr":
        r"""
        make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::string const & len_tag_key="frame_len", std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
        make(ofdm_carrier_allocator_cvc_sptr allocator, std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
        """
        return _digital_swig0.ofdm_serializer_vcc_make(*args)
    __swig_destroy__ = _digital_swig0.delete_ofdm_serializer_vcc

# Register ofdm_serializer_vcc in _digital_swig0:
_digital_swig0.ofdm_serializer_vcc_swigregister(ofdm_serializer_vcc)

def ofdm_serializer_vcc_make(*args) -> "gr::digital::ofdm_serializer_vcc::sptr":
    r"""
    ofdm_serializer_vcc_make(int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::string const & len_tag_key="frame_len", std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
    ofdm_serializer_vcc_make(ofdm_carrier_allocator_cvc_sptr allocator, std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
    """
    return _digital_swig0.ofdm_serializer_vcc_make(*args)

class ofdm_sync_sc_cfb(object):
    r"""Proxy of C++ gr::digital::ofdm_sync_sc_cfb 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(fft_len: "int", cp_len: "int", use_even_carriers: "bool"=False, threshold: "float"=0.9) -> "gr::digital::ofdm_sync_sc_cfb::sptr":
        r"""make(int fft_len, int cp_len, bool use_even_carriers=False, float threshold=0.9) -> ofdm_sync_sc_cfb_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_make(fft_len, cp_len, use_even_carriers, threshold)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(ofdm_sync_sc_cfb self, float threshold)"""
        return _digital_swig0.ofdm_sync_sc_cfb_set_threshold(self, threshold)

    def threshold(self) -> "float":
        r"""threshold(ofdm_sync_sc_cfb self) -> float"""
        return _digital_swig0.ofdm_sync_sc_cfb_threshold(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_sync_sc_cfb

# Register ofdm_sync_sc_cfb in _digital_swig0:
_digital_swig0.ofdm_sync_sc_cfb_swigregister(ofdm_sync_sc_cfb)

def ofdm_sync_sc_cfb_make(fft_len: "int", cp_len: "int", use_even_carriers: "bool"=False, threshold: "float"=0.9) -> "gr::digital::ofdm_sync_sc_cfb::sptr":
    r"""ofdm_sync_sc_cfb_make(int fft_len, int cp_len, bool use_even_carriers=False, float threshold=0.9) -> ofdm_sync_sc_cfb_sptr"""
    return _digital_swig0.ofdm_sync_sc_cfb_make(fft_len, cp_len, use_even_carriers, threshold)

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

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

    def __init__(self, *args):
        r"""
        __init__(binary_slicer_fb_sptr self) -> binary_slicer_fb_sptr
        __init__(binary_slicer_fb_sptr self, binary_slicer_fb p) -> binary_slicer_fb_sptr
        """
        _digital_swig0.binary_slicer_fb_sptr_swiginit(self, _digital_swig0.new_binary_slicer_fb_sptr(*args))

    def __deref__(self) -> "gr::digital::binary_slicer_fb *":
        r"""__deref__(binary_slicer_fb_sptr self) -> binary_slicer_fb"""
        return _digital_swig0.binary_slicer_fb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_binary_slicer_fb_sptr

    def make(self) -> "gr::digital::binary_slicer_fb::sptr":
        r"""make(binary_slicer_fb_sptr self) -> binary_slicer_fb_sptr"""
        return _digital_swig0.binary_slicer_fb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(binary_slicer_fb_sptr self) -> unsigned int"""
        return _digital_swig0.binary_slicer_fb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(binary_slicer_fb_sptr self, int which, int delay)
        declare_sample_delay(binary_slicer_fb_sptr self, unsigned int delay)
        """
        return _digital_swig0.binary_slicer_fb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(binary_slicer_fb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.binary_slicer_fb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(binary_slicer_fb_sptr self, int multiple)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(binary_slicer_fb_sptr self) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(binary_slicer_fb_sptr self) -> double"""
        return _digital_swig0.binary_slicer_fb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(binary_slicer_fb_sptr self) -> uint64_t"""
        return _digital_swig0.binary_slicer_fb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(binary_slicer_fb_sptr self) -> uint64_t"""
        return _digital_swig0.binary_slicer_fb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(binary_slicer_fb_sptr self) -> bool"""
        return _digital_swig0.binary_slicer_fb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(binary_slicer_fb_sptr self) -> bool"""
        return _digital_swig0.binary_slicer_fb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(binary_slicer_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.binary_slicer_fb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(binary_slicer_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.binary_slicer_fb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(binary_slicer_fb_sptr self, std::string level)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(binary_slicer_fb_sptr self) -> std::string"""
        return _digital_swig0.binary_slicer_fb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(binary_slicer_fb_sptr self) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(binary_slicer_fb_sptr self, int m)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(binary_slicer_fb_sptr self)"""
        return _digital_swig0.binary_slicer_fb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(binary_slicer_fb_sptr self) -> bool"""
        return _digital_swig0.binary_slicer_fb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(binary_slicer_fb_sptr self, int m)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(binary_slicer_fb_sptr self) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(binary_slicer_fb_sptr self, int i) -> long"""
        return _digital_swig0.binary_slicer_fb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(binary_slicer_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(binary_slicer_fb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.binary_slicer_fb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(binary_slicer_fb_sptr self, int i) -> long"""
        return _digital_swig0.binary_slicer_fb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(binary_slicer_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(binary_slicer_fb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.binary_slicer_fb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(binary_slicer_fb_sptr self, int which) -> float
        pc_input_buffers_full(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(binary_slicer_fb_sptr self, int which) -> float
        pc_input_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(binary_slicer_fb_sptr self, int which) -> float
        pc_input_buffers_full_var(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(binary_slicer_fb_sptr self, int which) -> float
        pc_output_buffers_full(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(binary_slicer_fb_sptr self, int which) -> float
        pc_output_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(binary_slicer_fb_sptr self, int which) -> float
        pc_output_buffers_full_var(binary_slicer_fb_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.binary_slicer_fb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(binary_slicer_fb_sptr self) -> float"""
        return _digital_swig0.binary_slicer_fb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(binary_slicer_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(binary_slicer_fb_sptr self)"""
        return _digital_swig0.binary_slicer_fb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(binary_slicer_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.binary_slicer_fb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(binary_slicer_fb_sptr self) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(binary_slicer_fb_sptr self) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(binary_slicer_fb_sptr self, int priority) -> int"""
        return _digital_swig0.binary_slicer_fb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(binary_slicer_fb_sptr self) -> std::string"""
        return _digital_swig0.binary_slicer_fb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(binary_slicer_fb_sptr self) -> std::string"""
        return _digital_swig0.binary_slicer_fb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(binary_slicer_fb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.binary_slicer_fb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(binary_slicer_fb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.binary_slicer_fb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(binary_slicer_fb_sptr self) -> long"""
        return _digital_swig0.binary_slicer_fb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(binary_slicer_fb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.binary_slicer_fb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(binary_slicer_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.binary_slicer_fb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(binary_slicer_fb_sptr self) -> std::string"""
        return _digital_swig0.binary_slicer_fb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(binary_slicer_fb_sptr self, std::string name)"""
        return _digital_swig0.binary_slicer_fb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(binary_slicer_fb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.binary_slicer_fb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(binary_slicer_fb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.binary_slicer_fb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(binary_slicer_fb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.binary_slicer_fb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(binary_slicer_fb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.binary_slicer_fb_sptr_message_subscribers(self, which_port)

# Register binary_slicer_fb_sptr in _digital_swig0:
_digital_swig0.binary_slicer_fb_sptr_swigregister(binary_slicer_fb_sptr)


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

class cma_equalizer_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::cma_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__(cma_equalizer_cc_sptr self) -> cma_equalizer_cc_sptr
        __init__(cma_equalizer_cc_sptr self, cma_equalizer_cc p) -> cma_equalizer_cc_sptr
        """
        _digital_swig0.cma_equalizer_cc_sptr_swiginit(self, _digital_swig0.new_cma_equalizer_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::cma_equalizer_cc *":
        r"""__deref__(cma_equalizer_cc_sptr self) -> cma_equalizer_cc"""
        return _digital_swig0.cma_equalizer_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_cma_equalizer_cc_sptr

    def make(self, num_taps: "int", modulus: "float", mu: "float", sps: "int") -> "gr::digital::cma_equalizer_cc::sptr":
        r"""make(cma_equalizer_cc_sptr self, int num_taps, float modulus, float mu, int sps) -> cma_equalizer_cc_sptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_make(self, num_taps, modulus, mu, sps)

    def set_taps(self, taps: "pmt_vector_cfloat") -> "void":
        r"""set_taps(cma_equalizer_cc_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_taps(self, taps)

    def taps(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""taps(cma_equalizer_cc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.cma_equalizer_cc_sptr_taps(self)

    def gain(self) -> "float":
        r"""gain(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(cma_equalizer_cc_sptr self, float mu)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_gain(self, mu)

    def modulus(self) -> "float":
        r"""modulus(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_modulus(self)

    def set_modulus(self, mod: "float") -> "void":
        r"""set_modulus(cma_equalizer_cc_sptr self, float mod)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_modulus(self, mod)

    def history(self) -> "unsigned int":
        r"""history(cma_equalizer_cc_sptr self) -> unsigned int"""
        return _digital_swig0.cma_equalizer_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(cma_equalizer_cc_sptr self, int which, int delay)
        declare_sample_delay(cma_equalizer_cc_sptr self, unsigned int delay)
        """
        return _digital_swig0.cma_equalizer_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(cma_equalizer_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.cma_equalizer_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(cma_equalizer_cc_sptr self, int multiple)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(cma_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(cma_equalizer_cc_sptr self) -> double"""
        return _digital_swig0.cma_equalizer_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(cma_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig0.cma_equalizer_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(cma_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig0.cma_equalizer_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(cma_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.cma_equalizer_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(cma_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.cma_equalizer_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(cma_equalizer_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.cma_equalizer_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(cma_equalizer_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.cma_equalizer_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(cma_equalizer_cc_sptr self, std::string level)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(cma_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.cma_equalizer_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(cma_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(cma_equalizer_cc_sptr self, int m)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(cma_equalizer_cc_sptr self)"""
        return _digital_swig0.cma_equalizer_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(cma_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.cma_equalizer_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(cma_equalizer_cc_sptr self, int m)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(cma_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(cma_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig0.cma_equalizer_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(cma_equalizer_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(cma_equalizer_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.cma_equalizer_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(cma_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig0.cma_equalizer_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(cma_equalizer_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(cma_equalizer_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.cma_equalizer_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(cma_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.cma_equalizer_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_equalizer_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(cma_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.cma_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(cma_equalizer_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(cma_equalizer_cc_sptr self)"""
        return _digital_swig0.cma_equalizer_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(cma_equalizer_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.cma_equalizer_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(cma_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(cma_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(cma_equalizer_cc_sptr self, int priority) -> int"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(cma_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.cma_equalizer_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(cma_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.cma_equalizer_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(cma_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(cma_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(cma_equalizer_cc_sptr self) -> long"""
        return _digital_swig0.cma_equalizer_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(cma_equalizer_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(cma_equalizer_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.cma_equalizer_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(cma_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.cma_equalizer_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(cma_equalizer_cc_sptr self, std::string name)"""
        return _digital_swig0.cma_equalizer_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(cma_equalizer_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.cma_equalizer_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(cma_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(cma_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(cma_equalizer_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.cma_equalizer_cc_sptr_message_subscribers(self, which_port)

# Register cma_equalizer_cc_sptr in _digital_swig0:
_digital_swig0.cma_equalizer_cc_sptr_swigregister(cma_equalizer_cc_sptr)


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

class constellation_decoder_cb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_decoder_cb > 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__(constellation_decoder_cb_sptr self) -> constellation_decoder_cb_sptr
        __init__(constellation_decoder_cb_sptr self, constellation_decoder_cb p) -> constellation_decoder_cb_sptr
        """
        _digital_swig0.constellation_decoder_cb_sptr_swiginit(self, _digital_swig0.new_constellation_decoder_cb_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_decoder_cb *":
        r"""__deref__(constellation_decoder_cb_sptr self) -> constellation_decoder_cb"""
        return _digital_swig0.constellation_decoder_cb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_decoder_cb_sptr

    def make(self, constellation: "constellation_sptr") -> "gr::digital::constellation_decoder_cb::sptr":
        r"""make(constellation_decoder_cb_sptr self, constellation_sptr constellation) -> constellation_decoder_cb_sptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_make(self, constellation)

    def history(self) -> "unsigned int":
        r"""history(constellation_decoder_cb_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_decoder_cb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(constellation_decoder_cb_sptr self, int which, int delay)
        declare_sample_delay(constellation_decoder_cb_sptr self, unsigned int delay)
        """
        return _digital_swig0.constellation_decoder_cb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(constellation_decoder_cb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.constellation_decoder_cb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(constellation_decoder_cb_sptr self, int multiple)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(constellation_decoder_cb_sptr self) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(constellation_decoder_cb_sptr self) -> double"""
        return _digital_swig0.constellation_decoder_cb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(constellation_decoder_cb_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_decoder_cb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(constellation_decoder_cb_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_decoder_cb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(constellation_decoder_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_decoder_cb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(constellation_decoder_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_decoder_cb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(constellation_decoder_cb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.constellation_decoder_cb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(constellation_decoder_cb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.constellation_decoder_cb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(constellation_decoder_cb_sptr self, std::string level)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(constellation_decoder_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_decoder_cb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(constellation_decoder_cb_sptr self) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(constellation_decoder_cb_sptr self, int m)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(constellation_decoder_cb_sptr self)"""
        return _digital_swig0.constellation_decoder_cb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(constellation_decoder_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_decoder_cb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(constellation_decoder_cb_sptr self, int m)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(constellation_decoder_cb_sptr self) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(constellation_decoder_cb_sptr self, int i) -> long"""
        return _digital_swig0.constellation_decoder_cb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(constellation_decoder_cb_sptr self, long max_output_buffer)
        set_max_output_buffer(constellation_decoder_cb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.constellation_decoder_cb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(constellation_decoder_cb_sptr self, int i) -> long"""
        return _digital_swig0.constellation_decoder_cb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(constellation_decoder_cb_sptr self, long min_output_buffer)
        set_min_output_buffer(constellation_decoder_cb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.constellation_decoder_cb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(constellation_decoder_cb_sptr self) -> float"""
        return _digital_swig0.constellation_decoder_cb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(constellation_decoder_cb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(constellation_decoder_cb_sptr self)"""
        return _digital_swig0.constellation_decoder_cb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(constellation_decoder_cb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_decoder_cb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(constellation_decoder_cb_sptr self) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(constellation_decoder_cb_sptr self) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(constellation_decoder_cb_sptr self, int priority) -> int"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(constellation_decoder_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_decoder_cb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(constellation_decoder_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_decoder_cb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(constellation_decoder_cb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(constellation_decoder_cb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(constellation_decoder_cb_sptr self) -> long"""
        return _digital_swig0.constellation_decoder_cb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(constellation_decoder_cb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(constellation_decoder_cb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.constellation_decoder_cb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(constellation_decoder_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_decoder_cb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(constellation_decoder_cb_sptr self, std::string name)"""
        return _digital_swig0.constellation_decoder_cb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(constellation_decoder_cb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.constellation_decoder_cb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(constellation_decoder_cb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(constellation_decoder_cb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(constellation_decoder_cb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_decoder_cb_sptr_message_subscribers(self, which_port)

# Register constellation_decoder_cb_sptr in _digital_swig0:
_digital_swig0.constellation_decoder_cb_sptr_swigregister(constellation_decoder_cb_sptr)


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

class constellation_receiver_cb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_receiver_cb > 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__(constellation_receiver_cb_sptr self) -> constellation_receiver_cb_sptr
        __init__(constellation_receiver_cb_sptr self, constellation_receiver_cb p) -> constellation_receiver_cb_sptr
        """
        _digital_swig0.constellation_receiver_cb_sptr_swiginit(self, _digital_swig0.new_constellation_receiver_cb_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_receiver_cb *":
        r"""__deref__(constellation_receiver_cb_sptr self) -> constellation_receiver_cb"""
        return _digital_swig0.constellation_receiver_cb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_receiver_cb_sptr

    def make(self, constellation: "constellation_sptr", loop_bw: "float", fmin: "float", fmax: "float") -> "gr::digital::constellation_receiver_cb::sptr":
        r"""make(constellation_receiver_cb_sptr self, constellation_sptr constellation, float loop_bw, float fmin, float fmax) -> constellation_receiver_cb_sptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_make(self, constellation, loop_bw, fmin, fmax)

    def phase_error_tracking(self, phase_error: "float") -> "void":
        r"""phase_error_tracking(constellation_receiver_cb_sptr self, float phase_error)"""
        return _digital_swig0.constellation_receiver_cb_sptr_phase_error_tracking(self, phase_error)

    def history(self) -> "unsigned int":
        r"""history(constellation_receiver_cb_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_receiver_cb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(constellation_receiver_cb_sptr self, int which, int delay)
        declare_sample_delay(constellation_receiver_cb_sptr self, unsigned int delay)
        """
        return _digital_swig0.constellation_receiver_cb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(constellation_receiver_cb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.constellation_receiver_cb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(constellation_receiver_cb_sptr self, int multiple)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(constellation_receiver_cb_sptr self) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(constellation_receiver_cb_sptr self) -> double"""
        return _digital_swig0.constellation_receiver_cb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(constellation_receiver_cb_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_receiver_cb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(constellation_receiver_cb_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_receiver_cb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(constellation_receiver_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_receiver_cb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(constellation_receiver_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_receiver_cb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(constellation_receiver_cb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.constellation_receiver_cb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(constellation_receiver_cb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.constellation_receiver_cb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(constellation_receiver_cb_sptr self, std::string level)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(constellation_receiver_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_receiver_cb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(constellation_receiver_cb_sptr self) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(constellation_receiver_cb_sptr self, int m)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(constellation_receiver_cb_sptr self)"""
        return _digital_swig0.constellation_receiver_cb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(constellation_receiver_cb_sptr self) -> bool"""
        return _digital_swig0.constellation_receiver_cb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(constellation_receiver_cb_sptr self, int m)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(constellation_receiver_cb_sptr self) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(constellation_receiver_cb_sptr self, int i) -> long"""
        return _digital_swig0.constellation_receiver_cb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(constellation_receiver_cb_sptr self, long max_output_buffer)
        set_max_output_buffer(constellation_receiver_cb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.constellation_receiver_cb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(constellation_receiver_cb_sptr self, int i) -> long"""
        return _digital_swig0.constellation_receiver_cb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(constellation_receiver_cb_sptr self, long min_output_buffer)
        set_min_output_buffer(constellation_receiver_cb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.constellation_receiver_cb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(constellation_receiver_cb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(constellation_receiver_cb_sptr self)"""
        return _digital_swig0.constellation_receiver_cb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(constellation_receiver_cb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_receiver_cb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(constellation_receiver_cb_sptr self) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(constellation_receiver_cb_sptr self) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(constellation_receiver_cb_sptr self, int priority) -> int"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(constellation_receiver_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_receiver_cb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(constellation_receiver_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_receiver_cb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(constellation_receiver_cb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(constellation_receiver_cb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(constellation_receiver_cb_sptr self) -> long"""
        return _digital_swig0.constellation_receiver_cb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(constellation_receiver_cb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(constellation_receiver_cb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.constellation_receiver_cb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(constellation_receiver_cb_sptr self) -> std::string"""
        return _digital_swig0.constellation_receiver_cb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(constellation_receiver_cb_sptr self, std::string name)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(constellation_receiver_cb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.constellation_receiver_cb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(constellation_receiver_cb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(constellation_receiver_cb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(constellation_receiver_cb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_receiver_cb_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(constellation_receiver_cb_sptr self)"""
        return _digital_swig0.constellation_receiver_cb_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(constellation_receiver_cb_sptr self, float error)"""
        return _digital_swig0.constellation_receiver_cb_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(constellation_receiver_cb_sptr self)"""
        return _digital_swig0.constellation_receiver_cb_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(constellation_receiver_cb_sptr self)"""
        return _digital_swig0.constellation_receiver_cb_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(constellation_receiver_cb_sptr self, float bw)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(constellation_receiver_cb_sptr self, float df)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(constellation_receiver_cb_sptr self, float alpha)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(constellation_receiver_cb_sptr self, float beta)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(constellation_receiver_cb_sptr self, float freq)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(constellation_receiver_cb_sptr self, float phase)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(constellation_receiver_cb_sptr self, float freq)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(constellation_receiver_cb_sptr self, float freq)"""
        return _digital_swig0.constellation_receiver_cb_sptr_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(constellation_receiver_cb_sptr self) -> float"""
        return _digital_swig0.constellation_receiver_cb_sptr_get_min_freq(self)

# Register constellation_receiver_cb_sptr in _digital_swig0:
_digital_swig0.constellation_receiver_cb_sptr_swigregister(constellation_receiver_cb_sptr)


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

class constellation_soft_decoder_cf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_soft_decoder_cf > 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__(constellation_soft_decoder_cf_sptr self) -> constellation_soft_decoder_cf_sptr
        __init__(constellation_soft_decoder_cf_sptr self, constellation_soft_decoder_cf p) -> constellation_soft_decoder_cf_sptr
        """
        _digital_swig0.constellation_soft_decoder_cf_sptr_swiginit(self, _digital_swig0.new_constellation_soft_decoder_cf_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_soft_decoder_cf *":
        r"""__deref__(constellation_soft_decoder_cf_sptr self) -> constellation_soft_decoder_cf"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_soft_decoder_cf_sptr

    def make(self, constellation: "constellation_sptr") -> "gr::digital::constellation_soft_decoder_cf::sptr":
        r"""make(constellation_soft_decoder_cf_sptr self, constellation_sptr constellation) -> constellation_soft_decoder_cf_sptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_make(self, constellation)

    def history(self) -> "unsigned int":
        r"""history(constellation_soft_decoder_cf_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(constellation_soft_decoder_cf_sptr self, int which, int delay)
        declare_sample_delay(constellation_soft_decoder_cf_sptr self, unsigned int delay)
        """
        return _digital_swig0.constellation_soft_decoder_cf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(constellation_soft_decoder_cf_sptr self, int which) -> unsigned int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(constellation_soft_decoder_cf_sptr self, int multiple)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(constellation_soft_decoder_cf_sptr self) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(constellation_soft_decoder_cf_sptr self) -> double"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(constellation_soft_decoder_cf_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(constellation_soft_decoder_cf_sptr self) -> uint64_t"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(constellation_soft_decoder_cf_sptr self) -> bool"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(constellation_soft_decoder_cf_sptr self) -> bool"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(constellation_soft_decoder_cf_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(constellation_soft_decoder_cf_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(constellation_soft_decoder_cf_sptr self, std::string level)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(constellation_soft_decoder_cf_sptr self) -> std::string"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(constellation_soft_decoder_cf_sptr self) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(constellation_soft_decoder_cf_sptr self, int m)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(constellation_soft_decoder_cf_sptr self)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(constellation_soft_decoder_cf_sptr self) -> bool"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(constellation_soft_decoder_cf_sptr self, int m)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(constellation_soft_decoder_cf_sptr self) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(constellation_soft_decoder_cf_sptr self, int i) -> long"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(constellation_soft_decoder_cf_sptr self, long max_output_buffer)
        set_max_output_buffer(constellation_soft_decoder_cf_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(constellation_soft_decoder_cf_sptr self, int i) -> long"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(constellation_soft_decoder_cf_sptr self, long min_output_buffer)
        set_min_output_buffer(constellation_soft_decoder_cf_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(constellation_soft_decoder_cf_sptr self) -> float"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(constellation_soft_decoder_cf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(constellation_soft_decoder_cf_sptr self)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(constellation_soft_decoder_cf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(constellation_soft_decoder_cf_sptr self) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(constellation_soft_decoder_cf_sptr self) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(constellation_soft_decoder_cf_sptr self, int priority) -> int"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(constellation_soft_decoder_cf_sptr self) -> std::string"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(constellation_soft_decoder_cf_sptr self) -> std::string"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(constellation_soft_decoder_cf_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(constellation_soft_decoder_cf_sptr self) -> io_signature_sptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(constellation_soft_decoder_cf_sptr self) -> long"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(constellation_soft_decoder_cf_sptr self) -> basic_block_sptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(constellation_soft_decoder_cf_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(constellation_soft_decoder_cf_sptr self) -> std::string"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(constellation_soft_decoder_cf_sptr self, std::string name)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(constellation_soft_decoder_cf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(constellation_soft_decoder_cf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(constellation_soft_decoder_cf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(constellation_soft_decoder_cf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_soft_decoder_cf_sptr_message_subscribers(self, which_port)

# Register constellation_soft_decoder_cf_sptr in _digital_swig0:
_digital_swig0.constellation_soft_decoder_cf_sptr_swigregister(constellation_soft_decoder_cf_sptr)


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

class corr_est_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::corr_est_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__(corr_est_cc_sptr self) -> corr_est_cc_sptr
        __init__(corr_est_cc_sptr self, corr_est_cc p) -> corr_est_cc_sptr
        """
        _digital_swig0.corr_est_cc_sptr_swiginit(self, _digital_swig0.new_corr_est_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::corr_est_cc *":
        r"""__deref__(corr_est_cc_sptr self) -> corr_est_cc"""
        return _digital_swig0.corr_est_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_corr_est_cc_sptr

    def make(self, *args, **kwargs) -> "gr::digital::corr_est_cc::sptr":
        r"""make(corr_est_cc_sptr self, pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9, gr::digital::tm_type threshold_method=THRESHOLD_ABSOLUTE) -> corr_est_cc_sptr"""
        return _digital_swig0.corr_est_cc_sptr_make(self, *args, **kwargs)

    def symbols(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""symbols(corr_est_cc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.corr_est_cc_sptr_symbols(self)

    def set_symbols(self, symbols: "pmt_vector_cfloat") -> "void":
        r"""set_symbols(corr_est_cc_sptr self, pmt_vector_cfloat symbols)"""
        return _digital_swig0.corr_est_cc_sptr_set_symbols(self, symbols)

    def mark_delay(self) -> "unsigned int":
        r"""mark_delay(corr_est_cc_sptr self) -> unsigned int"""
        return _digital_swig0.corr_est_cc_sptr_mark_delay(self)

    def set_mark_delay(self, mark_delay: "unsigned int") -> "void":
        r"""set_mark_delay(corr_est_cc_sptr self, unsigned int mark_delay)"""
        return _digital_swig0.corr_est_cc_sptr_set_mark_delay(self, mark_delay)

    def threshold(self) -> "float":
        r"""threshold(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_threshold(self)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(corr_est_cc_sptr self, float threshold)"""
        return _digital_swig0.corr_est_cc_sptr_set_threshold(self, threshold)

    def history(self) -> "unsigned int":
        r"""history(corr_est_cc_sptr self) -> unsigned int"""
        return _digital_swig0.corr_est_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(corr_est_cc_sptr self, int which, int delay)
        declare_sample_delay(corr_est_cc_sptr self, unsigned int delay)
        """
        return _digital_swig0.corr_est_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(corr_est_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.corr_est_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(corr_est_cc_sptr self, int multiple)"""
        return _digital_swig0.corr_est_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(corr_est_cc_sptr self) -> int"""
        return _digital_swig0.corr_est_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(corr_est_cc_sptr self) -> double"""
        return _digital_swig0.corr_est_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(corr_est_cc_sptr self) -> uint64_t"""
        return _digital_swig0.corr_est_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(corr_est_cc_sptr self) -> uint64_t"""
        return _digital_swig0.corr_est_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(corr_est_cc_sptr self) -> bool"""
        return _digital_swig0.corr_est_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(corr_est_cc_sptr self) -> bool"""
        return _digital_swig0.corr_est_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(corr_est_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.corr_est_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(corr_est_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.corr_est_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(corr_est_cc_sptr self, std::string level)"""
        return _digital_swig0.corr_est_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(corr_est_cc_sptr self) -> std::string"""
        return _digital_swig0.corr_est_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(corr_est_cc_sptr self) -> int"""
        return _digital_swig0.corr_est_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(corr_est_cc_sptr self, int m)"""
        return _digital_swig0.corr_est_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(corr_est_cc_sptr self)"""
        return _digital_swig0.corr_est_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(corr_est_cc_sptr self) -> bool"""
        return _digital_swig0.corr_est_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(corr_est_cc_sptr self, int m)"""
        return _digital_swig0.corr_est_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(corr_est_cc_sptr self) -> int"""
        return _digital_swig0.corr_est_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(corr_est_cc_sptr self, int i) -> long"""
        return _digital_swig0.corr_est_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(corr_est_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(corr_est_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.corr_est_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(corr_est_cc_sptr self, int i) -> long"""
        return _digital_swig0.corr_est_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(corr_est_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(corr_est_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.corr_est_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(corr_est_cc_sptr self) -> float"""
        return _digital_swig0.corr_est_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(corr_est_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.corr_est_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(corr_est_cc_sptr self)"""
        return _digital_swig0.corr_est_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(corr_est_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.corr_est_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(corr_est_cc_sptr self) -> int"""
        return _digital_swig0.corr_est_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(corr_est_cc_sptr self) -> int"""
        return _digital_swig0.corr_est_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(corr_est_cc_sptr self, int priority) -> int"""
        return _digital_swig0.corr_est_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(corr_est_cc_sptr self) -> std::string"""
        return _digital_swig0.corr_est_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(corr_est_cc_sptr self) -> std::string"""
        return _digital_swig0.corr_est_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(corr_est_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.corr_est_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(corr_est_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.corr_est_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(corr_est_cc_sptr self) -> long"""
        return _digital_swig0.corr_est_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(corr_est_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.corr_est_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(corr_est_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.corr_est_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(corr_est_cc_sptr self) -> std::string"""
        return _digital_swig0.corr_est_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(corr_est_cc_sptr self, std::string name)"""
        return _digital_swig0.corr_est_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(corr_est_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.corr_est_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(corr_est_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.corr_est_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(corr_est_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.corr_est_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(corr_est_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.corr_est_cc_sptr_message_subscribers(self, which_port)

# Register corr_est_cc_sptr in _digital_swig0:
_digital_swig0.corr_est_cc_sptr_swigregister(corr_est_cc_sptr)


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

class correlate_access_code_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::correlate_access_code_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__(correlate_access_code_bb_sptr self) -> correlate_access_code_bb_sptr
        __init__(correlate_access_code_bb_sptr self, correlate_access_code_bb p) -> correlate_access_code_bb_sptr
        """
        _digital_swig0.correlate_access_code_bb_sptr_swiginit(self, _digital_swig0.new_correlate_access_code_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::correlate_access_code_bb *":
        r"""__deref__(correlate_access_code_bb_sptr self) -> correlate_access_code_bb"""
        return _digital_swig0.correlate_access_code_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_bb_sptr

    def make(self, access_code: "std::string const &", threshold: "int") -> "gr::digital::correlate_access_code_bb::sptr":
        r"""make(correlate_access_code_bb_sptr self, std::string const & access_code, int threshold) -> correlate_access_code_bb_sptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_make(self, access_code, threshold)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_bb_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_access_code(self, access_code)

    def history(self) -> "unsigned int":
        r"""history(correlate_access_code_bb_sptr self) -> unsigned int"""
        return _digital_swig0.correlate_access_code_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(correlate_access_code_bb_sptr self, int which, int delay)
        declare_sample_delay(correlate_access_code_bb_sptr self, unsigned int delay)
        """
        return _digital_swig0.correlate_access_code_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(correlate_access_code_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.correlate_access_code_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(correlate_access_code_bb_sptr self, int multiple)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(correlate_access_code_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(correlate_access_code_bb_sptr self) -> double"""
        return _digital_swig0.correlate_access_code_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(correlate_access_code_bb_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(correlate_access_code_bb_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(correlate_access_code_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(correlate_access_code_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(correlate_access_code_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(correlate_access_code_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(correlate_access_code_bb_sptr self, std::string level)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(correlate_access_code_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(correlate_access_code_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(correlate_access_code_bb_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(correlate_access_code_bb_sptr self)"""
        return _digital_swig0.correlate_access_code_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(correlate_access_code_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(correlate_access_code_bb_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(correlate_access_code_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(correlate_access_code_bb_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(correlate_access_code_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(correlate_access_code_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.correlate_access_code_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(correlate_access_code_bb_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(correlate_access_code_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(correlate_access_code_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.correlate_access_code_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(correlate_access_code_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(correlate_access_code_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(correlate_access_code_bb_sptr self)"""
        return _digital_swig0.correlate_access_code_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(correlate_access_code_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.correlate_access_code_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(correlate_access_code_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(correlate_access_code_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(correlate_access_code_bb_sptr self, int priority) -> int"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(correlate_access_code_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(correlate_access_code_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(correlate_access_code_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(correlate_access_code_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(correlate_access_code_bb_sptr self) -> long"""
        return _digital_swig0.correlate_access_code_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(correlate_access_code_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(correlate_access_code_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.correlate_access_code_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(correlate_access_code_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(correlate_access_code_bb_sptr self, std::string name)"""
        return _digital_swig0.correlate_access_code_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(correlate_access_code_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.correlate_access_code_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(correlate_access_code_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(correlate_access_code_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(correlate_access_code_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_sptr_message_subscribers(self, which_port)

# Register correlate_access_code_bb_sptr in _digital_swig0:
_digital_swig0.correlate_access_code_bb_sptr_swigregister(correlate_access_code_bb_sptr)


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

class correlate_access_code_tag_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::correlate_access_code_tag_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__(correlate_access_code_tag_bb_sptr self) -> correlate_access_code_tag_bb_sptr
        __init__(correlate_access_code_tag_bb_sptr self, correlate_access_code_tag_bb p) -> correlate_access_code_tag_bb_sptr
        """
        _digital_swig0.correlate_access_code_tag_bb_sptr_swiginit(self, _digital_swig0.new_correlate_access_code_tag_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::correlate_access_code_tag_bb *":
        r"""__deref__(correlate_access_code_tag_bb_sptr self) -> correlate_access_code_tag_bb"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_tag_bb_sptr

    def make(self, access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_bb::sptr":
        r"""make(correlate_access_code_tag_bb_sptr self, std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_bb_sptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_make(self, access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_tag_bb_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_access_code(self, access_code)

    def set_threshold(self, threshold: "int") -> "void":
        r"""set_threshold(correlate_access_code_tag_bb_sptr self, int threshold)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_threshold(self, threshold)

    def set_tagname(self, tagname: "std::string const &") -> "void":
        r"""set_tagname(correlate_access_code_tag_bb_sptr self, std::string const & tagname)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_tagname(self, tagname)

    def history(self) -> "unsigned int":
        r"""history(correlate_access_code_tag_bb_sptr self) -> unsigned int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(correlate_access_code_tag_bb_sptr self, int which, int delay)
        declare_sample_delay(correlate_access_code_tag_bb_sptr self, unsigned int delay)
        """
        return _digital_swig0.correlate_access_code_tag_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(correlate_access_code_tag_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(correlate_access_code_tag_bb_sptr self, int multiple)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(correlate_access_code_tag_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(correlate_access_code_tag_bb_sptr self) -> double"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(correlate_access_code_tag_bb_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(correlate_access_code_tag_bb_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(correlate_access_code_tag_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(correlate_access_code_tag_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(correlate_access_code_tag_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(correlate_access_code_tag_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(correlate_access_code_tag_bb_sptr self, std::string level)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(correlate_access_code_tag_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(correlate_access_code_tag_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(correlate_access_code_tag_bb_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(correlate_access_code_tag_bb_sptr self)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(correlate_access_code_tag_bb_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(correlate_access_code_tag_bb_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(correlate_access_code_tag_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(correlate_access_code_tag_bb_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(correlate_access_code_tag_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(correlate_access_code_tag_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(correlate_access_code_tag_bb_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(correlate_access_code_tag_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(correlate_access_code_tag_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(correlate_access_code_tag_bb_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(correlate_access_code_tag_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(correlate_access_code_tag_bb_sptr self)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(correlate_access_code_tag_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(correlate_access_code_tag_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(correlate_access_code_tag_bb_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(correlate_access_code_tag_bb_sptr self, int priority) -> int"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(correlate_access_code_tag_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(correlate_access_code_tag_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(correlate_access_code_tag_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(correlate_access_code_tag_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(correlate_access_code_tag_bb_sptr self) -> long"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(correlate_access_code_tag_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(correlate_access_code_tag_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(correlate_access_code_tag_bb_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(correlate_access_code_tag_bb_sptr self, std::string name)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(correlate_access_code_tag_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(correlate_access_code_tag_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(correlate_access_code_tag_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(correlate_access_code_tag_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_bb_sptr_message_subscribers(self, which_port)

# Register correlate_access_code_tag_bb_sptr in _digital_swig0:
_digital_swig0.correlate_access_code_tag_bb_sptr_swigregister(correlate_access_code_tag_bb_sptr)


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

class correlate_access_code_tag_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::correlate_access_code_tag_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__(correlate_access_code_tag_ff_sptr self) -> correlate_access_code_tag_ff_sptr
        __init__(correlate_access_code_tag_ff_sptr self, correlate_access_code_tag_ff p) -> correlate_access_code_tag_ff_sptr
        """
        _digital_swig0.correlate_access_code_tag_ff_sptr_swiginit(self, _digital_swig0.new_correlate_access_code_tag_ff_sptr(*args))

    def __deref__(self) -> "gr::digital::correlate_access_code_tag_ff *":
        r"""__deref__(correlate_access_code_tag_ff_sptr self) -> correlate_access_code_tag_ff"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_tag_ff_sptr

    def make(self, access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_tag_ff::sptr":
        r"""make(correlate_access_code_tag_ff_sptr self, std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_tag_ff_sptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_make(self, access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_tag_ff_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_access_code(self, access_code)

    def set_threshold(self, threshold: "int") -> "void":
        r"""set_threshold(correlate_access_code_tag_ff_sptr self, int threshold)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_threshold(self, threshold)

    def set_tagname(self, tagname: "std::string const &") -> "void":
        r"""set_tagname(correlate_access_code_tag_ff_sptr self, std::string const & tagname)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_tagname(self, tagname)

    def history(self) -> "unsigned int":
        r"""history(correlate_access_code_tag_ff_sptr self) -> unsigned int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(correlate_access_code_tag_ff_sptr self, int which, int delay)
        declare_sample_delay(correlate_access_code_tag_ff_sptr self, unsigned int delay)
        """
        return _digital_swig0.correlate_access_code_tag_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(correlate_access_code_tag_ff_sptr self, int which) -> unsigned int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(correlate_access_code_tag_ff_sptr self, int multiple)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(correlate_access_code_tag_ff_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(correlate_access_code_tag_ff_sptr self) -> double"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(correlate_access_code_tag_ff_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(correlate_access_code_tag_ff_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(correlate_access_code_tag_ff_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(correlate_access_code_tag_ff_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(correlate_access_code_tag_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(correlate_access_code_tag_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(correlate_access_code_tag_ff_sptr self, std::string level)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(correlate_access_code_tag_ff_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(correlate_access_code_tag_ff_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(correlate_access_code_tag_ff_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(correlate_access_code_tag_ff_sptr self)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(correlate_access_code_tag_ff_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(correlate_access_code_tag_ff_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(correlate_access_code_tag_ff_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(correlate_access_code_tag_ff_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(correlate_access_code_tag_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(correlate_access_code_tag_ff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(correlate_access_code_tag_ff_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(correlate_access_code_tag_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(correlate_access_code_tag_ff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(correlate_access_code_tag_ff_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(correlate_access_code_tag_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(correlate_access_code_tag_ff_sptr self)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(correlate_access_code_tag_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(correlate_access_code_tag_ff_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(correlate_access_code_tag_ff_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(correlate_access_code_tag_ff_sptr self, int priority) -> int"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(correlate_access_code_tag_ff_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(correlate_access_code_tag_ff_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(correlate_access_code_tag_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(correlate_access_code_tag_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(correlate_access_code_tag_ff_sptr self) -> long"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(correlate_access_code_tag_ff_sptr self) -> basic_block_sptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(correlate_access_code_tag_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(correlate_access_code_tag_ff_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(correlate_access_code_tag_ff_sptr self, std::string name)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(correlate_access_code_tag_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(correlate_access_code_tag_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(correlate_access_code_tag_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(correlate_access_code_tag_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_tag_ff_sptr_message_subscribers(self, which_port)

# Register correlate_access_code_tag_ff_sptr in _digital_swig0:
_digital_swig0.correlate_access_code_tag_ff_sptr_swigregister(correlate_access_code_tag_ff_sptr)


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

class correlate_access_code_bb_ts_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::correlate_access_code_bb_ts > 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__(correlate_access_code_bb_ts_sptr self) -> correlate_access_code_bb_ts_sptr
        __init__(correlate_access_code_bb_ts_sptr self, correlate_access_code_bb_ts p) -> correlate_access_code_bb_ts_sptr
        """
        _digital_swig0.correlate_access_code_bb_ts_sptr_swiginit(self, _digital_swig0.new_correlate_access_code_bb_ts_sptr(*args))

    def __deref__(self) -> "gr::digital::correlate_access_code_bb_ts *":
        r"""__deref__(correlate_access_code_bb_ts_sptr self) -> correlate_access_code_bb_ts"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_bb_ts_sptr

    def make(self, access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_bb_ts::sptr":
        r"""make(correlate_access_code_bb_ts_sptr self, std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_bb_ts_sptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_make(self, access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_bb_ts_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(correlate_access_code_bb_ts_sptr self) -> unsigned long long"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_access_code(self)

    def history(self) -> "unsigned int":
        r"""history(correlate_access_code_bb_ts_sptr self) -> unsigned int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(correlate_access_code_bb_ts_sptr self, int which, int delay)
        declare_sample_delay(correlate_access_code_bb_ts_sptr self, unsigned int delay)
        """
        return _digital_swig0.correlate_access_code_bb_ts_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(correlate_access_code_bb_ts_sptr self, int which) -> unsigned int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(correlate_access_code_bb_ts_sptr self, int multiple)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(correlate_access_code_bb_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(correlate_access_code_bb_ts_sptr self) -> double"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(correlate_access_code_bb_ts_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(correlate_access_code_bb_ts_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(correlate_access_code_bb_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(correlate_access_code_bb_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(correlate_access_code_bb_ts_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(correlate_access_code_bb_ts_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(correlate_access_code_bb_ts_sptr self, std::string level)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(correlate_access_code_bb_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(correlate_access_code_bb_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(correlate_access_code_bb_ts_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(correlate_access_code_bb_ts_sptr self)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(correlate_access_code_bb_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(correlate_access_code_bb_ts_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(correlate_access_code_bb_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(correlate_access_code_bb_ts_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(correlate_access_code_bb_ts_sptr self, long max_output_buffer)
        set_max_output_buffer(correlate_access_code_bb_ts_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(correlate_access_code_bb_ts_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(correlate_access_code_bb_ts_sptr self, long min_output_buffer)
        set_min_output_buffer(correlate_access_code_bb_ts_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(correlate_access_code_bb_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(correlate_access_code_bb_ts_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(correlate_access_code_bb_ts_sptr self)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(correlate_access_code_bb_ts_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(correlate_access_code_bb_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(correlate_access_code_bb_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(correlate_access_code_bb_ts_sptr self, int priority) -> int"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(correlate_access_code_bb_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(correlate_access_code_bb_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(correlate_access_code_bb_ts_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(correlate_access_code_bb_ts_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(correlate_access_code_bb_ts_sptr self) -> long"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(correlate_access_code_bb_ts_sptr self) -> basic_block_sptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(correlate_access_code_bb_ts_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(correlate_access_code_bb_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(correlate_access_code_bb_ts_sptr self, std::string name)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(correlate_access_code_bb_ts_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(correlate_access_code_bb_ts_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(correlate_access_code_bb_ts_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(correlate_access_code_bb_ts_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_bb_ts_sptr_message_subscribers(self, which_port)

# Register correlate_access_code_bb_ts_sptr in _digital_swig0:
_digital_swig0.correlate_access_code_bb_ts_sptr_swigregister(correlate_access_code_bb_ts_sptr)


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

class correlate_access_code_ff_ts_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::correlate_access_code_ff_ts > 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__(correlate_access_code_ff_ts_sptr self) -> correlate_access_code_ff_ts_sptr
        __init__(correlate_access_code_ff_ts_sptr self, correlate_access_code_ff_ts p) -> correlate_access_code_ff_ts_sptr
        """
        _digital_swig0.correlate_access_code_ff_ts_sptr_swiginit(self, _digital_swig0.new_correlate_access_code_ff_ts_sptr(*args))

    def __deref__(self) -> "gr::digital::correlate_access_code_ff_ts *":
        r"""__deref__(correlate_access_code_ff_ts_sptr self) -> correlate_access_code_ff_ts"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_correlate_access_code_ff_ts_sptr

    def make(self, access_code: "std::string const &", threshold: "int", tag_name: "std::string const &") -> "gr::digital::correlate_access_code_ff_ts::sptr":
        r"""make(correlate_access_code_ff_ts_sptr self, std::string const & access_code, int threshold, std::string const & tag_name) -> correlate_access_code_ff_ts_sptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_make(self, access_code, threshold, tag_name)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(correlate_access_code_ff_ts_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(correlate_access_code_ff_ts_sptr self) -> unsigned long long"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_access_code(self)

    def history(self) -> "unsigned int":
        r"""history(correlate_access_code_ff_ts_sptr self) -> unsigned int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(correlate_access_code_ff_ts_sptr self, int which, int delay)
        declare_sample_delay(correlate_access_code_ff_ts_sptr self, unsigned int delay)
        """
        return _digital_swig0.correlate_access_code_ff_ts_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(correlate_access_code_ff_ts_sptr self, int which) -> unsigned int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(correlate_access_code_ff_ts_sptr self, int multiple)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(correlate_access_code_ff_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(correlate_access_code_ff_ts_sptr self) -> double"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(correlate_access_code_ff_ts_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(correlate_access_code_ff_ts_sptr self) -> uint64_t"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(correlate_access_code_ff_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(correlate_access_code_ff_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(correlate_access_code_ff_ts_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(correlate_access_code_ff_ts_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(correlate_access_code_ff_ts_sptr self, std::string level)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(correlate_access_code_ff_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(correlate_access_code_ff_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(correlate_access_code_ff_ts_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(correlate_access_code_ff_ts_sptr self)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(correlate_access_code_ff_ts_sptr self) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(correlate_access_code_ff_ts_sptr self, int m)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(correlate_access_code_ff_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(correlate_access_code_ff_ts_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(correlate_access_code_ff_ts_sptr self, long max_output_buffer)
        set_max_output_buffer(correlate_access_code_ff_ts_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(correlate_access_code_ff_ts_sptr self, int i) -> long"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(correlate_access_code_ff_ts_sptr self, long min_output_buffer)
        set_min_output_buffer(correlate_access_code_ff_ts_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(correlate_access_code_ff_ts_sptr self) -> float"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(correlate_access_code_ff_ts_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(correlate_access_code_ff_ts_sptr self)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(correlate_access_code_ff_ts_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(correlate_access_code_ff_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(correlate_access_code_ff_ts_sptr self) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(correlate_access_code_ff_ts_sptr self, int priority) -> int"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(correlate_access_code_ff_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(correlate_access_code_ff_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(correlate_access_code_ff_ts_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(correlate_access_code_ff_ts_sptr self) -> io_signature_sptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(correlate_access_code_ff_ts_sptr self) -> long"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(correlate_access_code_ff_ts_sptr self) -> basic_block_sptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(correlate_access_code_ff_ts_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(correlate_access_code_ff_ts_sptr self) -> std::string"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(correlate_access_code_ff_ts_sptr self, std::string name)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(correlate_access_code_ff_ts_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(correlate_access_code_ff_ts_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(correlate_access_code_ff_ts_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(correlate_access_code_ff_ts_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.correlate_access_code_ff_ts_sptr_message_subscribers(self, which_port)

# Register correlate_access_code_ff_ts_sptr in _digital_swig0:
_digital_swig0.correlate_access_code_ff_ts_sptr_swigregister(correlate_access_code_ff_ts_sptr)


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

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

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

    def __init__(self, *args):
        r"""
        __init__(costas_loop_cc_sptr self) -> costas_loop_cc_sptr
        __init__(costas_loop_cc_sptr self, costas_loop_cc p) -> costas_loop_cc_sptr
        """
        _digital_swig0.costas_loop_cc_sptr_swiginit(self, _digital_swig0.new_costas_loop_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::costas_loop_cc *":
        r"""__deref__(costas_loop_cc_sptr self) -> costas_loop_cc"""
        return _digital_swig0.costas_loop_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_costas_loop_cc_sptr

    def make(self, loop_bw: "float", order: "int", use_snr: "bool"=False) -> "gr::digital::costas_loop_cc::sptr":
        r"""make(costas_loop_cc_sptr self, float loop_bw, int order, bool use_snr=False) -> costas_loop_cc_sptr"""
        return _digital_swig0.costas_loop_cc_sptr_make(self, loop_bw, order, use_snr)

    def error(self) -> "float":
        r"""error(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_error(self)

    def history(self) -> "unsigned int":
        r"""history(costas_loop_cc_sptr self) -> unsigned int"""
        return _digital_swig0.costas_loop_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(costas_loop_cc_sptr self, int which, int delay)
        declare_sample_delay(costas_loop_cc_sptr self, unsigned int delay)
        """
        return _digital_swig0.costas_loop_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(costas_loop_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.costas_loop_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(costas_loop_cc_sptr self, int multiple)"""
        return _digital_swig0.costas_loop_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(costas_loop_cc_sptr self) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(costas_loop_cc_sptr self) -> double"""
        return _digital_swig0.costas_loop_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(costas_loop_cc_sptr self) -> uint64_t"""
        return _digital_swig0.costas_loop_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(costas_loop_cc_sptr self) -> uint64_t"""
        return _digital_swig0.costas_loop_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(costas_loop_cc_sptr self) -> bool"""
        return _digital_swig0.costas_loop_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(costas_loop_cc_sptr self) -> bool"""
        return _digital_swig0.costas_loop_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(costas_loop_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.costas_loop_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(costas_loop_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.costas_loop_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(costas_loop_cc_sptr self, std::string level)"""
        return _digital_swig0.costas_loop_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(costas_loop_cc_sptr self) -> std::string"""
        return _digital_swig0.costas_loop_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(costas_loop_cc_sptr self) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(costas_loop_cc_sptr self, int m)"""
        return _digital_swig0.costas_loop_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(costas_loop_cc_sptr self)"""
        return _digital_swig0.costas_loop_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(costas_loop_cc_sptr self) -> bool"""
        return _digital_swig0.costas_loop_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(costas_loop_cc_sptr self, int m)"""
        return _digital_swig0.costas_loop_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(costas_loop_cc_sptr self) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(costas_loop_cc_sptr self, int i) -> long"""
        return _digital_swig0.costas_loop_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(costas_loop_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(costas_loop_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.costas_loop_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(costas_loop_cc_sptr self, int i) -> long"""
        return _digital_swig0.costas_loop_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(costas_loop_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(costas_loop_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.costas_loop_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(costas_loop_cc_sptr self, int which) -> float
        pc_input_buffers_full(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(costas_loop_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(costas_loop_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(costas_loop_cc_sptr self, int which) -> float
        pc_output_buffers_full(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(costas_loop_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(costas_loop_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(costas_loop_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.costas_loop_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(costas_loop_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.costas_loop_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(costas_loop_cc_sptr self)"""
        return _digital_swig0.costas_loop_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(costas_loop_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.costas_loop_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(costas_loop_cc_sptr self) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(costas_loop_cc_sptr self) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(costas_loop_cc_sptr self, int priority) -> int"""
        return _digital_swig0.costas_loop_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(costas_loop_cc_sptr self) -> std::string"""
        return _digital_swig0.costas_loop_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(costas_loop_cc_sptr self) -> std::string"""
        return _digital_swig0.costas_loop_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(costas_loop_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.costas_loop_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(costas_loop_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.costas_loop_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(costas_loop_cc_sptr self) -> long"""
        return _digital_swig0.costas_loop_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(costas_loop_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.costas_loop_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(costas_loop_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.costas_loop_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(costas_loop_cc_sptr self) -> std::string"""
        return _digital_swig0.costas_loop_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(costas_loop_cc_sptr self, std::string name)"""
        return _digital_swig0.costas_loop_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(costas_loop_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.costas_loop_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(costas_loop_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.costas_loop_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(costas_loop_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.costas_loop_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(costas_loop_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.costas_loop_cc_sptr_message_subscribers(self, which_port)

    def update_gains(self) -> "void":
        r"""update_gains(costas_loop_cc_sptr self)"""
        return _digital_swig0.costas_loop_cc_sptr_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(costas_loop_cc_sptr self, float error)"""
        return _digital_swig0.costas_loop_cc_sptr_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(costas_loop_cc_sptr self)"""
        return _digital_swig0.costas_loop_cc_sptr_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(costas_loop_cc_sptr self)"""
        return _digital_swig0.costas_loop_cc_sptr_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(costas_loop_cc_sptr self, float bw)"""
        return _digital_swig0.costas_loop_cc_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(costas_loop_cc_sptr self, float df)"""
        return _digital_swig0.costas_loop_cc_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(costas_loop_cc_sptr self, float alpha)"""
        return _digital_swig0.costas_loop_cc_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(costas_loop_cc_sptr self, float beta)"""
        return _digital_swig0.costas_loop_cc_sptr_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(costas_loop_cc_sptr self, float freq)"""
        return _digital_swig0.costas_loop_cc_sptr_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(costas_loop_cc_sptr self, float phase)"""
        return _digital_swig0.costas_loop_cc_sptr_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(costas_loop_cc_sptr self, float freq)"""
        return _digital_swig0.costas_loop_cc_sptr_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(costas_loop_cc_sptr self, float freq)"""
        return _digital_swig0.costas_loop_cc_sptr_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(costas_loop_cc_sptr self) -> float"""
        return _digital_swig0.costas_loop_cc_sptr_get_min_freq(self)

# Register costas_loop_cc_sptr in _digital_swig0:
_digital_swig0.costas_loop_cc_sptr_swigregister(costas_loop_cc_sptr)


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

class crc32_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::crc32_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__(crc32_bb_sptr self) -> crc32_bb_sptr
        __init__(crc32_bb_sptr self, crc32_bb p) -> crc32_bb_sptr
        """
        _digital_swig0.crc32_bb_sptr_swiginit(self, _digital_swig0.new_crc32_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::crc32_bb *":
        r"""__deref__(crc32_bb_sptr self) -> crc32_bb"""
        return _digital_swig0.crc32_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_crc32_bb_sptr

    def make(self, *args, **kwargs) -> "gr::digital::crc32_bb::sptr":
        r"""make(crc32_bb_sptr self, bool check=False, std::string const & lengthtagname="packet_len", bool packed=True) -> crc32_bb_sptr"""
        return _digital_swig0.crc32_bb_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(crc32_bb_sptr self) -> unsigned int"""
        return _digital_swig0.crc32_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(crc32_bb_sptr self, int which, int delay)
        declare_sample_delay(crc32_bb_sptr self, unsigned int delay)
        """
        return _digital_swig0.crc32_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(crc32_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.crc32_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(crc32_bb_sptr self, int multiple)"""
        return _digital_swig0.crc32_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(crc32_bb_sptr self) -> int"""
        return _digital_swig0.crc32_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(crc32_bb_sptr self) -> double"""
        return _digital_swig0.crc32_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(crc32_bb_sptr self) -> uint64_t"""
        return _digital_swig0.crc32_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(crc32_bb_sptr self) -> uint64_t"""
        return _digital_swig0.crc32_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(crc32_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(crc32_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(crc32_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.crc32_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(crc32_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.crc32_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(crc32_bb_sptr self, std::string level)"""
        return _digital_swig0.crc32_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(crc32_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(crc32_bb_sptr self) -> int"""
        return _digital_swig0.crc32_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(crc32_bb_sptr self, int m)"""
        return _digital_swig0.crc32_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(crc32_bb_sptr self)"""
        return _digital_swig0.crc32_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(crc32_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(crc32_bb_sptr self, int m)"""
        return _digital_swig0.crc32_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(crc32_bb_sptr self) -> int"""
        return _digital_swig0.crc32_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(crc32_bb_sptr self, int i) -> long"""
        return _digital_swig0.crc32_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(crc32_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(crc32_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.crc32_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(crc32_bb_sptr self, int i) -> long"""
        return _digital_swig0.crc32_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(crc32_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(crc32_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.crc32_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(crc32_bb_sptr self) -> float"""
        return _digital_swig0.crc32_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(crc32_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.crc32_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(crc32_bb_sptr self)"""
        return _digital_swig0.crc32_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(crc32_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.crc32_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(crc32_bb_sptr self) -> int"""
        return _digital_swig0.crc32_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(crc32_bb_sptr self) -> int"""
        return _digital_swig0.crc32_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(crc32_bb_sptr self, int priority) -> int"""
        return _digital_swig0.crc32_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(crc32_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(crc32_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(crc32_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.crc32_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(crc32_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.crc32_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(crc32_bb_sptr self) -> long"""
        return _digital_swig0.crc32_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(crc32_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.crc32_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(crc32_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.crc32_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(crc32_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(crc32_bb_sptr self, std::string name)"""
        return _digital_swig0.crc32_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(crc32_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.crc32_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(crc32_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(crc32_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(crc32_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_bb_sptr_message_subscribers(self, which_port)

# Register crc32_bb_sptr in _digital_swig0:
_digital_swig0.crc32_bb_sptr_swigregister(crc32_bb_sptr)


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

class crc32_async_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::crc32_async_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__(crc32_async_bb_sptr self) -> crc32_async_bb_sptr
        __init__(crc32_async_bb_sptr self, crc32_async_bb p) -> crc32_async_bb_sptr
        """
        _digital_swig0.crc32_async_bb_sptr_swiginit(self, _digital_swig0.new_crc32_async_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::crc32_async_bb *":
        r"""__deref__(crc32_async_bb_sptr self) -> crc32_async_bb"""
        return _digital_swig0.crc32_async_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_crc32_async_bb_sptr

    def make(self, check: "bool"=False) -> "gr::digital::crc32_async_bb::sptr":
        r"""make(crc32_async_bb_sptr self, bool check=False) -> crc32_async_bb_sptr"""
        return _digital_swig0.crc32_async_bb_sptr_make(self, check)

    def history(self) -> "unsigned int":
        r"""history(crc32_async_bb_sptr self) -> unsigned int"""
        return _digital_swig0.crc32_async_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(crc32_async_bb_sptr self, int which, int delay)
        declare_sample_delay(crc32_async_bb_sptr self, unsigned int delay)
        """
        return _digital_swig0.crc32_async_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(crc32_async_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.crc32_async_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(crc32_async_bb_sptr self, int multiple)"""
        return _digital_swig0.crc32_async_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(crc32_async_bb_sptr self) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(crc32_async_bb_sptr self) -> double"""
        return _digital_swig0.crc32_async_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(crc32_async_bb_sptr self) -> uint64_t"""
        return _digital_swig0.crc32_async_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(crc32_async_bb_sptr self) -> uint64_t"""
        return _digital_swig0.crc32_async_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(crc32_async_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_async_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(crc32_async_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_async_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(crc32_async_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.crc32_async_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(crc32_async_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.crc32_async_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(crc32_async_bb_sptr self, std::string level)"""
        return _digital_swig0.crc32_async_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(crc32_async_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_async_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(crc32_async_bb_sptr self) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(crc32_async_bb_sptr self, int m)"""
        return _digital_swig0.crc32_async_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(crc32_async_bb_sptr self)"""
        return _digital_swig0.crc32_async_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(crc32_async_bb_sptr self) -> bool"""
        return _digital_swig0.crc32_async_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(crc32_async_bb_sptr self, int m)"""
        return _digital_swig0.crc32_async_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(crc32_async_bb_sptr self) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(crc32_async_bb_sptr self, int i) -> long"""
        return _digital_swig0.crc32_async_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(crc32_async_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(crc32_async_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.crc32_async_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(crc32_async_bb_sptr self, int i) -> long"""
        return _digital_swig0.crc32_async_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(crc32_async_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(crc32_async_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.crc32_async_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(crc32_async_bb_sptr self) -> float"""
        return _digital_swig0.crc32_async_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(crc32_async_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.crc32_async_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(crc32_async_bb_sptr self)"""
        return _digital_swig0.crc32_async_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(crc32_async_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.crc32_async_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(crc32_async_bb_sptr self) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(crc32_async_bb_sptr self) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(crc32_async_bb_sptr self, int priority) -> int"""
        return _digital_swig0.crc32_async_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(crc32_async_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_async_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(crc32_async_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_async_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(crc32_async_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.crc32_async_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(crc32_async_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.crc32_async_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(crc32_async_bb_sptr self) -> long"""
        return _digital_swig0.crc32_async_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(crc32_async_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.crc32_async_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(crc32_async_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.crc32_async_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(crc32_async_bb_sptr self) -> std::string"""
        return _digital_swig0.crc32_async_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(crc32_async_bb_sptr self, std::string name)"""
        return _digital_swig0.crc32_async_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(crc32_async_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.crc32_async_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(crc32_async_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_async_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(crc32_async_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_async_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(crc32_async_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.crc32_async_bb_sptr_message_subscribers(self, which_port)

# Register crc32_async_bb_sptr in _digital_swig0:
_digital_swig0.crc32_async_bb_sptr_swigregister(crc32_async_bb_sptr)


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

class cpmmod_bc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::cpmmod_bc > 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__(cpmmod_bc_sptr self) -> cpmmod_bc_sptr
        __init__(cpmmod_bc_sptr self, cpmmod_bc p) -> cpmmod_bc_sptr
        """
        _digital_swig0.cpmmod_bc_sptr_swiginit(self, _digital_swig0.new_cpmmod_bc_sptr(*args))

    def __deref__(self) -> "gr::digital::cpmmod_bc *":
        r"""__deref__(cpmmod_bc_sptr self) -> cpmmod_bc"""
        return _digital_swig0.cpmmod_bc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_cpmmod_bc_sptr

    def make(self, type: "gr::analog::cpm::cpm_type", h: "float", samples_per_sym: "int", L: "int", beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make(cpmmod_bc_sptr self, gr::analog::cpm::cpm_type type, float h, int samples_per_sym, int L, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_make(self, type, h, samples_per_sym, L, beta)

    def make_gmskmod_bc(self, samples_per_sym: "int"=2, L: "int"=4, beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make_gmskmod_bc(cpmmod_bc_sptr self, int samples_per_sym=2, int L=4, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_make_gmskmod_bc(self, samples_per_sym, L, beta)

    def taps(self) -> "std::vector< float,std::allocator< float > >":
        r"""taps(cpmmod_bc_sptr self) -> pmt_vector_float"""
        return _digital_swig0.cpmmod_bc_sptr_taps(self)

    def type(self) -> "int":
        r"""type(cpmmod_bc_sptr self) -> int"""
        return _digital_swig0.cpmmod_bc_sptr_type(self)

    def index(self) -> "float":
        r"""index(cpmmod_bc_sptr self) -> float"""
        return _digital_swig0.cpmmod_bc_sptr_index(self)

    def samples_per_sym(self) -> "int":
        r"""samples_per_sym(cpmmod_bc_sptr self) -> int"""
        return _digital_swig0.cpmmod_bc_sptr_samples_per_sym(self)

    def length(self) -> "int":
        r"""length(cpmmod_bc_sptr self) -> int"""
        return _digital_swig0.cpmmod_bc_sptr_length(self)

    def beta(self) -> "double":
        r"""beta(cpmmod_bc_sptr self) -> double"""
        return _digital_swig0.cpmmod_bc_sptr_beta(self)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(cpmmod_bc_sptr self, basic_block_sptr block)
        primitive_connect(cpmmod_bc_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.cpmmod_bc_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(cpmmod_bc_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(cpmmod_bc_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.cpmmod_bc_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(cpmmod_bc_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(cpmmod_bc_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.cpmmod_bc_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(cpmmod_bc_sptr self, basic_block_sptr block)
        primitive_disconnect(cpmmod_bc_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.cpmmod_bc_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(cpmmod_bc_sptr self)"""
        return _digital_swig0.cpmmod_bc_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(cpmmod_bc_sptr self)"""
        return _digital_swig0.cpmmod_bc_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(cpmmod_bc_sptr self)"""
        return _digital_swig0.cpmmod_bc_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(cpmmod_bc_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.cpmmod_bc_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(cpmmod_bc_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.cpmmod_bc_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(cpmmod_bc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.cpmmod_bc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(cpmmod_bc_sptr self)"""
        return _digital_swig0.cpmmod_bc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(cpmmod_bc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.cpmmod_bc_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(cpmmod_bc_sptr self, std::string level)"""
        return _digital_swig0.cpmmod_bc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(cpmmod_bc_sptr self) -> std::string"""
        return _digital_swig0.cpmmod_bc_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(cpmmod_bc_sptr self, int i) -> size_t"""
        return _digital_swig0.cpmmod_bc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(cpmmod_bc_sptr self, size_t max_output_buffer)
        set_max_output_buffer(cpmmod_bc_sptr self, int port, size_t max_output_buffer)
        """
        return _digital_swig0.cpmmod_bc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(cpmmod_bc_sptr self, int i) -> size_t"""
        return _digital_swig0.cpmmod_bc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(cpmmod_bc_sptr self, size_t min_output_buffer)
        set_min_output_buffer(cpmmod_bc_sptr self, int port, size_t min_output_buffer)
        """
        return _digital_swig0.cpmmod_bc_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(cpmmod_bc_sptr self) -> hier_block2_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(cpmmod_bc_sptr self) -> std::string"""
        return _digital_swig0.cpmmod_bc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(cpmmod_bc_sptr self) -> std::string"""
        return _digital_swig0.cpmmod_bc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(cpmmod_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(cpmmod_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(cpmmod_bc_sptr self) -> long"""
        return _digital_swig0.cpmmod_bc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(cpmmod_bc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.cpmmod_bc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(cpmmod_bc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.cpmmod_bc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(cpmmod_bc_sptr self) -> std::string"""
        return _digital_swig0.cpmmod_bc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(cpmmod_bc_sptr self, std::string name)"""
        return _digital_swig0.cpmmod_bc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(cpmmod_bc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.cpmmod_bc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(cpmmod_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.cpmmod_bc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(cpmmod_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.cpmmod_bc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(cpmmod_bc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.cpmmod_bc_sptr_message_subscribers(self, which_port)

# Register cpmmod_bc_sptr in _digital_swig0:
_digital_swig0.cpmmod_bc_sptr_swigregister(cpmmod_bc_sptr)


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

class descrambler_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::descrambler_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__(descrambler_bb_sptr self) -> descrambler_bb_sptr
        __init__(descrambler_bb_sptr self, descrambler_bb p) -> descrambler_bb_sptr
        """
        _digital_swig0.descrambler_bb_sptr_swiginit(self, _digital_swig0.new_descrambler_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::descrambler_bb *":
        r"""__deref__(descrambler_bb_sptr self) -> descrambler_bb"""
        return _digital_swig0.descrambler_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_descrambler_bb_sptr

    def make(self, mask: "int", seed: "int", len: "int") -> "gr::digital::descrambler_bb::sptr":
        r"""make(descrambler_bb_sptr self, int mask, int seed, int len) -> descrambler_bb_sptr"""
        return _digital_swig0.descrambler_bb_sptr_make(self, mask, seed, len)

    def history(self) -> "unsigned int":
        r"""history(descrambler_bb_sptr self) -> unsigned int"""
        return _digital_swig0.descrambler_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(descrambler_bb_sptr self, int which, int delay)
        declare_sample_delay(descrambler_bb_sptr self, unsigned int delay)
        """
        return _digital_swig0.descrambler_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(descrambler_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig0.descrambler_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(descrambler_bb_sptr self, int multiple)"""
        return _digital_swig0.descrambler_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(descrambler_bb_sptr self) -> int"""
        return _digital_swig0.descrambler_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(descrambler_bb_sptr self) -> double"""
        return _digital_swig0.descrambler_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(descrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig0.descrambler_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(descrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig0.descrambler_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(descrambler_bb_sptr self) -> bool"""
        return _digital_swig0.descrambler_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(descrambler_bb_sptr self) -> bool"""
        return _digital_swig0.descrambler_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(descrambler_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.descrambler_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(descrambler_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.descrambler_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(descrambler_bb_sptr self, std::string level)"""
        return _digital_swig0.descrambler_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(descrambler_bb_sptr self) -> std::string"""
        return _digital_swig0.descrambler_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(descrambler_bb_sptr self) -> int"""
        return _digital_swig0.descrambler_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(descrambler_bb_sptr self, int m)"""
        return _digital_swig0.descrambler_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(descrambler_bb_sptr self)"""
        return _digital_swig0.descrambler_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(descrambler_bb_sptr self) -> bool"""
        return _digital_swig0.descrambler_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(descrambler_bb_sptr self, int m)"""
        return _digital_swig0.descrambler_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(descrambler_bb_sptr self) -> int"""
        return _digital_swig0.descrambler_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(descrambler_bb_sptr self, int i) -> long"""
        return _digital_swig0.descrambler_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(descrambler_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(descrambler_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.descrambler_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(descrambler_bb_sptr self, int i) -> long"""
        return _digital_swig0.descrambler_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(descrambler_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(descrambler_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.descrambler_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(descrambler_bb_sptr self) -> float"""
        return _digital_swig0.descrambler_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(descrambler_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.descrambler_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(descrambler_bb_sptr self)"""
        return _digital_swig0.descrambler_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(descrambler_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.descrambler_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(descrambler_bb_sptr self) -> int"""
        return _digital_swig0.descrambler_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(descrambler_bb_sptr self) -> int"""
        return _digital_swig0.descrambler_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(descrambler_bb_sptr self, int priority) -> int"""
        return _digital_swig0.descrambler_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(descrambler_bb_sptr self) -> std::string"""
        return _digital_swig0.descrambler_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(descrambler_bb_sptr self) -> std::string"""
        return _digital_swig0.descrambler_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(descrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.descrambler_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(descrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.descrambler_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(descrambler_bb_sptr self) -> long"""
        return _digital_swig0.descrambler_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(descrambler_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.descrambler_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(descrambler_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.descrambler_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(descrambler_bb_sptr self) -> std::string"""
        return _digital_swig0.descrambler_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(descrambler_bb_sptr self, std::string name)"""
        return _digital_swig0.descrambler_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(descrambler_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.descrambler_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(descrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.descrambler_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(descrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.descrambler_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(descrambler_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.descrambler_bb_sptr_message_subscribers(self, which_port)

# Register descrambler_bb_sptr in _digital_swig0:
_digital_swig0.descrambler_bb_sptr_swigregister(descrambler_bb_sptr)


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

class lms_dd_equalizer_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::lms_dd_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__(lms_dd_equalizer_cc_sptr self) -> lms_dd_equalizer_cc_sptr
        __init__(lms_dd_equalizer_cc_sptr self, lms_dd_equalizer_cc p) -> lms_dd_equalizer_cc_sptr
        """
        _digital_swig0.lms_dd_equalizer_cc_sptr_swiginit(self, _digital_swig0.new_lms_dd_equalizer_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::lms_dd_equalizer_cc *":
        r"""__deref__(lms_dd_equalizer_cc_sptr self) -> lms_dd_equalizer_cc"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_lms_dd_equalizer_cc_sptr

    def make(self, num_taps: "int", mu: "float", sps: "int", cnst: "constellation_sptr") -> "gr::digital::lms_dd_equalizer_cc::sptr":
        r"""make(lms_dd_equalizer_cc_sptr self, int num_taps, float mu, int sps, constellation_sptr cnst) -> lms_dd_equalizer_cc_sptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_make(self, num_taps, mu, sps, cnst)

    def set_taps(self, taps: "pmt_vector_cfloat") -> "void":
        r"""set_taps(lms_dd_equalizer_cc_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_taps(self, taps)

    def taps(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""taps(lms_dd_equalizer_cc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_taps(self)

    def gain(self) -> "float":
        r"""gain(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_gain(self)

    def set_gain(self, mu: "float") -> "void":
        r"""set_gain(lms_dd_equalizer_cc_sptr self, float mu)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_gain(self, mu)

    def history(self) -> "unsigned int":
        r"""history(lms_dd_equalizer_cc_sptr self) -> unsigned int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(lms_dd_equalizer_cc_sptr self, int which, int delay)
        declare_sample_delay(lms_dd_equalizer_cc_sptr self, unsigned int delay)
        """
        return _digital_swig0.lms_dd_equalizer_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(lms_dd_equalizer_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(lms_dd_equalizer_cc_sptr self, int multiple)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(lms_dd_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(lms_dd_equalizer_cc_sptr self) -> double"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(lms_dd_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(lms_dd_equalizer_cc_sptr self) -> uint64_t"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(lms_dd_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(lms_dd_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(lms_dd_equalizer_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(lms_dd_equalizer_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(lms_dd_equalizer_cc_sptr self, std::string level)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(lms_dd_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(lms_dd_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(lms_dd_equalizer_cc_sptr self, int m)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(lms_dd_equalizer_cc_sptr self)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(lms_dd_equalizer_cc_sptr self) -> bool"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(lms_dd_equalizer_cc_sptr self, int m)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(lms_dd_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(lms_dd_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(lms_dd_equalizer_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(lms_dd_equalizer_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(lms_dd_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(lms_dd_equalizer_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(lms_dd_equalizer_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(lms_dd_equalizer_cc_sptr self) -> float"""
        return _digital_swig0.lms_dd_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(lms_dd_equalizer_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(lms_dd_equalizer_cc_sptr self)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(lms_dd_equalizer_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(lms_dd_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(lms_dd_equalizer_cc_sptr self) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(lms_dd_equalizer_cc_sptr self, int priority) -> int"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(lms_dd_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(lms_dd_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(lms_dd_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(lms_dd_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(lms_dd_equalizer_cc_sptr self) -> long"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(lms_dd_equalizer_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(lms_dd_equalizer_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(lms_dd_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(lms_dd_equalizer_cc_sptr self, std::string name)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(lms_dd_equalizer_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(lms_dd_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(lms_dd_equalizer_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(lms_dd_equalizer_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.lms_dd_equalizer_cc_sptr_message_subscribers(self, which_port)

# Register lms_dd_equalizer_cc_sptr in _digital_swig0:
_digital_swig0.lms_dd_equalizer_cc_sptr_swigregister(lms_dd_equalizer_cc_sptr)


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

class ofdm_carrier_allocator_cvc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_carrier_allocator_cvc > 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__(ofdm_carrier_allocator_cvc_sptr self) -> ofdm_carrier_allocator_cvc_sptr
        __init__(ofdm_carrier_allocator_cvc_sptr self, ofdm_carrier_allocator_cvc p) -> ofdm_carrier_allocator_cvc_sptr
        """
        _digital_swig0.ofdm_carrier_allocator_cvc_sptr_swiginit(self, _digital_swig0.new_ofdm_carrier_allocator_cvc_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_carrier_allocator_cvc *":
        r"""__deref__(ofdm_carrier_allocator_cvc_sptr self) -> ofdm_carrier_allocator_cvc"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_carrier_allocator_cvc_sptr

    def len_tag_key(self) -> "std::string":
        r"""len_tag_key(ofdm_carrier_allocator_cvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_len_tag_key(self)

    def fft_len(self) -> "int const":
        r"""fft_len(ofdm_carrier_allocator_cvc_sptr self) -> int const"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_fft_len(self)

    def occupied_carriers(self) -> "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >":
        r"""occupied_carriers(ofdm_carrier_allocator_cvc_sptr self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_occupied_carriers(self)

    def make(self, *args, **kwargs) -> "gr::digital::ofdm_carrier_allocator_cvc::sptr":
        r"""make(ofdm_carrier_allocator_cvc_sptr self, int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers, gr_vector_vector_complexf pilot_symbols, gr_vector_vector_complexf sync_words, std::string const & len_tag_key="packet_len", bool const output_is_shifted=True) -> ofdm_carrier_allocator_cvc_sptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(ofdm_carrier_allocator_cvc_sptr self) -> unsigned int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ofdm_carrier_allocator_cvc_sptr self, int which, int delay)
        declare_sample_delay(ofdm_carrier_allocator_cvc_sptr self, unsigned int delay)
        """
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ofdm_carrier_allocator_cvc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ofdm_carrier_allocator_cvc_sptr self, int multiple)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ofdm_carrier_allocator_cvc_sptr self) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ofdm_carrier_allocator_cvc_sptr self) -> double"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ofdm_carrier_allocator_cvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ofdm_carrier_allocator_cvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ofdm_carrier_allocator_cvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ofdm_carrier_allocator_cvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ofdm_carrier_allocator_cvc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ofdm_carrier_allocator_cvc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_carrier_allocator_cvc_sptr self, std::string level)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_carrier_allocator_cvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ofdm_carrier_allocator_cvc_sptr self) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ofdm_carrier_allocator_cvc_sptr self, int m)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ofdm_carrier_allocator_cvc_sptr self)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ofdm_carrier_allocator_cvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ofdm_carrier_allocator_cvc_sptr self, int m)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ofdm_carrier_allocator_cvc_sptr self) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ofdm_carrier_allocator_cvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_carrier_allocator_cvc_sptr self, long max_output_buffer)
        set_max_output_buffer(ofdm_carrier_allocator_cvc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ofdm_carrier_allocator_cvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_carrier_allocator_cvc_sptr self, long min_output_buffer)
        set_min_output_buffer(ofdm_carrier_allocator_cvc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ofdm_carrier_allocator_cvc_sptr self) -> float"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_carrier_allocator_cvc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_carrier_allocator_cvc_sptr self)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_carrier_allocator_cvc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ofdm_carrier_allocator_cvc_sptr self) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ofdm_carrier_allocator_cvc_sptr self) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ofdm_carrier_allocator_cvc_sptr self, int priority) -> int"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ofdm_carrier_allocator_cvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_carrier_allocator_cvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_carrier_allocator_cvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_carrier_allocator_cvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_carrier_allocator_cvc_sptr self) -> long"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_carrier_allocator_cvc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_carrier_allocator_cvc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_carrier_allocator_cvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_carrier_allocator_cvc_sptr self, std::string name)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_carrier_allocator_cvc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_carrier_allocator_cvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_carrier_allocator_cvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_carrier_allocator_cvc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_carrier_allocator_cvc_sptr_message_subscribers(self, which_port)

# Register ofdm_carrier_allocator_cvc_sptr in _digital_swig0:
_digital_swig0.ofdm_carrier_allocator_cvc_sptr_swigregister(ofdm_carrier_allocator_cvc_sptr)


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

class ofdm_chanest_vcvc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_chanest_vcvc > 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__(ofdm_chanest_vcvc_sptr self) -> ofdm_chanest_vcvc_sptr
        __init__(ofdm_chanest_vcvc_sptr self, ofdm_chanest_vcvc p) -> ofdm_chanest_vcvc_sptr
        """
        _digital_swig0.ofdm_chanest_vcvc_sptr_swiginit(self, _digital_swig0.new_ofdm_chanest_vcvc_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_chanest_vcvc *":
        r"""__deref__(ofdm_chanest_vcvc_sptr self) -> ofdm_chanest_vcvc"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_chanest_vcvc_sptr

    def make(self, sync_symbol1: "pmt_vector_cfloat", sync_symbol2: "pmt_vector_cfloat", n_data_symbols: "int", eq_noise_red_len: "int"=0, max_carr_offset: "int"=-1, force_one_sync_symbol: "bool"=False) -> "gr::digital::ofdm_chanest_vcvc::sptr":
        r"""make(ofdm_chanest_vcvc_sptr self, pmt_vector_cfloat sync_symbol1, pmt_vector_cfloat sync_symbol2, int n_data_symbols, int eq_noise_red_len=0, int max_carr_offset=-1, bool force_one_sync_symbol=False) -> ofdm_chanest_vcvc_sptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_make(self, sync_symbol1, sync_symbol2, n_data_symbols, eq_noise_red_len, max_carr_offset, force_one_sync_symbol)

    def history(self) -> "unsigned int":
        r"""history(ofdm_chanest_vcvc_sptr self) -> unsigned int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ofdm_chanest_vcvc_sptr self, int which, int delay)
        declare_sample_delay(ofdm_chanest_vcvc_sptr self, unsigned int delay)
        """
        return _digital_swig0.ofdm_chanest_vcvc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ofdm_chanest_vcvc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ofdm_chanest_vcvc_sptr self, int multiple)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ofdm_chanest_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ofdm_chanest_vcvc_sptr self) -> double"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ofdm_chanest_vcvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ofdm_chanest_vcvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ofdm_chanest_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ofdm_chanest_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ofdm_chanest_vcvc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ofdm_chanest_vcvc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_chanest_vcvc_sptr self, std::string level)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_chanest_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ofdm_chanest_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ofdm_chanest_vcvc_sptr self, int m)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ofdm_chanest_vcvc_sptr self)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ofdm_chanest_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ofdm_chanest_vcvc_sptr self, int m)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ofdm_chanest_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ofdm_chanest_vcvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_chanest_vcvc_sptr self, long max_output_buffer)
        set_max_output_buffer(ofdm_chanest_vcvc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ofdm_chanest_vcvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_chanest_vcvc_sptr self, long min_output_buffer)
        set_min_output_buffer(ofdm_chanest_vcvc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ofdm_chanest_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_chanest_vcvc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_chanest_vcvc_sptr self)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_chanest_vcvc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ofdm_chanest_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ofdm_chanest_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ofdm_chanest_vcvc_sptr self, int priority) -> int"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ofdm_chanest_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_chanest_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_chanest_vcvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_chanest_vcvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_chanest_vcvc_sptr self) -> long"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_chanest_vcvc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_chanest_vcvc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_chanest_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_chanest_vcvc_sptr self, std::string name)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_chanest_vcvc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_chanest_vcvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_chanest_vcvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_chanest_vcvc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_chanest_vcvc_sptr_message_subscribers(self, which_port)

# Register ofdm_chanest_vcvc_sptr in _digital_swig0:
_digital_swig0.ofdm_chanest_vcvc_sptr_swigregister(ofdm_chanest_vcvc_sptr)


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

class ofdm_cyclic_prefixer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_cyclic_prefixer > 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__(ofdm_cyclic_prefixer_sptr self) -> ofdm_cyclic_prefixer_sptr
        __init__(ofdm_cyclic_prefixer_sptr self, ofdm_cyclic_prefixer p) -> ofdm_cyclic_prefixer_sptr
        """
        _digital_swig0.ofdm_cyclic_prefixer_sptr_swiginit(self, _digital_swig0.new_ofdm_cyclic_prefixer_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_cyclic_prefixer *":
        r"""__deref__(ofdm_cyclic_prefixer_sptr self) -> ofdm_cyclic_prefixer"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_cyclic_prefixer_sptr

    def make(self, *args, **kwargs) -> "gr::digital::ofdm_cyclic_prefixer::sptr":
        r"""make(ofdm_cyclic_prefixer_sptr self, size_t input_size, size_t output_size, int rolloff_len=0, std::string const & len_tag_key="") -> ofdm_cyclic_prefixer_sptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(ofdm_cyclic_prefixer_sptr self) -> unsigned int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ofdm_cyclic_prefixer_sptr self, int which, int delay)
        declare_sample_delay(ofdm_cyclic_prefixer_sptr self, unsigned int delay)
        """
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ofdm_cyclic_prefixer_sptr self, int which) -> unsigned int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ofdm_cyclic_prefixer_sptr self, int multiple)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ofdm_cyclic_prefixer_sptr self) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ofdm_cyclic_prefixer_sptr self) -> double"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ofdm_cyclic_prefixer_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ofdm_cyclic_prefixer_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ofdm_cyclic_prefixer_sptr self) -> bool"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ofdm_cyclic_prefixer_sptr self) -> bool"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ofdm_cyclic_prefixer_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ofdm_cyclic_prefixer_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_cyclic_prefixer_sptr self, std::string level)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_cyclic_prefixer_sptr self) -> std::string"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ofdm_cyclic_prefixer_sptr self) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ofdm_cyclic_prefixer_sptr self, int m)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ofdm_cyclic_prefixer_sptr self)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ofdm_cyclic_prefixer_sptr self) -> bool"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ofdm_cyclic_prefixer_sptr self, int m)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ofdm_cyclic_prefixer_sptr self) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ofdm_cyclic_prefixer_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_cyclic_prefixer_sptr self, long max_output_buffer)
        set_max_output_buffer(ofdm_cyclic_prefixer_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ofdm_cyclic_prefixer_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_cyclic_prefixer_sptr self, long min_output_buffer)
        set_min_output_buffer(ofdm_cyclic_prefixer_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ofdm_cyclic_prefixer_sptr self) -> float"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_cyclic_prefixer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_cyclic_prefixer_sptr self)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_cyclic_prefixer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ofdm_cyclic_prefixer_sptr self) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ofdm_cyclic_prefixer_sptr self) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ofdm_cyclic_prefixer_sptr self, int priority) -> int"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ofdm_cyclic_prefixer_sptr self) -> std::string"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_cyclic_prefixer_sptr self) -> std::string"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_cyclic_prefixer_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_cyclic_prefixer_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_cyclic_prefixer_sptr self) -> long"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_cyclic_prefixer_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_cyclic_prefixer_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_cyclic_prefixer_sptr self) -> std::string"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_cyclic_prefixer_sptr self, std::string name)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_cyclic_prefixer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_cyclic_prefixer_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_cyclic_prefixer_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_cyclic_prefixer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_cyclic_prefixer_sptr_message_subscribers(self, which_port)

# Register ofdm_cyclic_prefixer_sptr in _digital_swig0:
_digital_swig0.ofdm_cyclic_prefixer_sptr_swigregister(ofdm_cyclic_prefixer_sptr)


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

class ofdm_frame_equalizer_vcvc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_frame_equalizer_vcvc > 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__(ofdm_frame_equalizer_vcvc_sptr self) -> ofdm_frame_equalizer_vcvc_sptr
        __init__(ofdm_frame_equalizer_vcvc_sptr self, ofdm_frame_equalizer_vcvc p) -> ofdm_frame_equalizer_vcvc_sptr
        """
        _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_swiginit(self, _digital_swig0.new_ofdm_frame_equalizer_vcvc_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_frame_equalizer_vcvc *":
        r"""__deref__(ofdm_frame_equalizer_vcvc_sptr self) -> ofdm_frame_equalizer_vcvc"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_frame_equalizer_vcvc_sptr

    def make(self, *args, **kwargs) -> "gr::digital::ofdm_frame_equalizer_vcvc::sptr":
        r"""make(ofdm_frame_equalizer_vcvc_sptr self, ofdm_equalizer_base_sptr equalizer, int cp_len, std::string const & tsb_key="frame_len", bool propagate_channel_state=False, int fixed_frame_len=0) -> ofdm_frame_equalizer_vcvc_sptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(ofdm_frame_equalizer_vcvc_sptr self) -> unsigned int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ofdm_frame_equalizer_vcvc_sptr self, int which, int delay)
        declare_sample_delay(ofdm_frame_equalizer_vcvc_sptr self, unsigned int delay)
        """
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ofdm_frame_equalizer_vcvc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ofdm_frame_equalizer_vcvc_sptr self, int multiple)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ofdm_frame_equalizer_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ofdm_frame_equalizer_vcvc_sptr self) -> double"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ofdm_frame_equalizer_vcvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ofdm_frame_equalizer_vcvc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ofdm_frame_equalizer_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ofdm_frame_equalizer_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ofdm_frame_equalizer_vcvc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ofdm_frame_equalizer_vcvc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_frame_equalizer_vcvc_sptr self, std::string level)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_frame_equalizer_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ofdm_frame_equalizer_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ofdm_frame_equalizer_vcvc_sptr self, int m)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ofdm_frame_equalizer_vcvc_sptr self)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ofdm_frame_equalizer_vcvc_sptr self) -> bool"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ofdm_frame_equalizer_vcvc_sptr self, int m)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ofdm_frame_equalizer_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, long max_output_buffer)
        set_max_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, long min_output_buffer)
        set_min_output_buffer(ofdm_frame_equalizer_vcvc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ofdm_frame_equalizer_vcvc_sptr self) -> float"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_frame_equalizer_vcvc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_frame_equalizer_vcvc_sptr self)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_frame_equalizer_vcvc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ofdm_frame_equalizer_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ofdm_frame_equalizer_vcvc_sptr self) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ofdm_frame_equalizer_vcvc_sptr self, int priority) -> int"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ofdm_frame_equalizer_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_frame_equalizer_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_frame_equalizer_vcvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_frame_equalizer_vcvc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_frame_equalizer_vcvc_sptr self) -> long"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_frame_equalizer_vcvc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_frame_equalizer_vcvc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_frame_equalizer_vcvc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_frame_equalizer_vcvc_sptr self, std::string name)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_frame_equalizer_vcvc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_frame_equalizer_vcvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_frame_equalizer_vcvc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_frame_equalizer_vcvc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_frame_equalizer_vcvc_sptr_message_subscribers(self, which_port)

# Register ofdm_frame_equalizer_vcvc_sptr in _digital_swig0:
_digital_swig0.ofdm_frame_equalizer_vcvc_sptr_swigregister(ofdm_frame_equalizer_vcvc_sptr)


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

class ofdm_serializer_vcc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_serializer_vcc > 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__(ofdm_serializer_vcc_sptr self) -> ofdm_serializer_vcc_sptr
        __init__(ofdm_serializer_vcc_sptr self, ofdm_serializer_vcc p) -> ofdm_serializer_vcc_sptr
        """
        _digital_swig0.ofdm_serializer_vcc_sptr_swiginit(self, _digital_swig0.new_ofdm_serializer_vcc_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_serializer_vcc *":
        r"""__deref__(ofdm_serializer_vcc_sptr self) -> ofdm_serializer_vcc"""
        return _digital_swig0.ofdm_serializer_vcc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_serializer_vcc_sptr

    def make(self, *args) -> "gr::digital::ofdm_serializer_vcc::sptr":
        r"""
        make(ofdm_serializer_vcc_sptr self, int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, std::string const & len_tag_key="frame_len", std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
        make(ofdm_serializer_vcc_sptr self, ofdm_carrier_allocator_cvc_sptr allocator, std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
        """
        return _digital_swig0.ofdm_serializer_vcc_sptr_make(self, *args)

    def history(self) -> "unsigned int":
        r"""history(ofdm_serializer_vcc_sptr self) -> unsigned int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ofdm_serializer_vcc_sptr self, int which, int delay)
        declare_sample_delay(ofdm_serializer_vcc_sptr self, unsigned int delay)
        """
        return _digital_swig0.ofdm_serializer_vcc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ofdm_serializer_vcc_sptr self, int which) -> unsigned int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ofdm_serializer_vcc_sptr self, int multiple)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ofdm_serializer_vcc_sptr self) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ofdm_serializer_vcc_sptr self) -> double"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ofdm_serializer_vcc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ofdm_serializer_vcc_sptr self) -> uint64_t"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ofdm_serializer_vcc_sptr self) -> bool"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ofdm_serializer_vcc_sptr self) -> bool"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ofdm_serializer_vcc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ofdm_serializer_vcc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_serializer_vcc_sptr self, std::string level)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_serializer_vcc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ofdm_serializer_vcc_sptr self) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ofdm_serializer_vcc_sptr self, int m)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ofdm_serializer_vcc_sptr self)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ofdm_serializer_vcc_sptr self) -> bool"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ofdm_serializer_vcc_sptr self, int m)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ofdm_serializer_vcc_sptr self) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ofdm_serializer_vcc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_serializer_vcc_sptr self, long max_output_buffer)
        set_max_output_buffer(ofdm_serializer_vcc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ofdm_serializer_vcc_sptr self, int i) -> long"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_serializer_vcc_sptr self, long min_output_buffer)
        set_min_output_buffer(ofdm_serializer_vcc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ofdm_serializer_vcc_sptr self) -> float"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_serializer_vcc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_serializer_vcc_sptr self)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_serializer_vcc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ofdm_serializer_vcc_sptr self) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ofdm_serializer_vcc_sptr self) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ofdm_serializer_vcc_sptr self, int priority) -> int"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ofdm_serializer_vcc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_serializer_vcc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_serializer_vcc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_serializer_vcc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_serializer_vcc_sptr self) -> long"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_serializer_vcc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_serializer_vcc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_serializer_vcc_sptr self) -> std::string"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_serializer_vcc_sptr self, std::string name)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_serializer_vcc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_serializer_vcc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_serializer_vcc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_serializer_vcc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_serializer_vcc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_serializer_vcc_sptr_message_subscribers(self, which_port)

# Register ofdm_serializer_vcc_sptr in _digital_swig0:
_digital_swig0.ofdm_serializer_vcc_sptr_swigregister(ofdm_serializer_vcc_sptr)


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

class ofdm_sync_sc_cfb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_sync_sc_cfb > 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__(ofdm_sync_sc_cfb_sptr self) -> ofdm_sync_sc_cfb_sptr
        __init__(ofdm_sync_sc_cfb_sptr self, ofdm_sync_sc_cfb p) -> ofdm_sync_sc_cfb_sptr
        """
        _digital_swig0.ofdm_sync_sc_cfb_sptr_swiginit(self, _digital_swig0.new_ofdm_sync_sc_cfb_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_sync_sc_cfb *":
        r"""__deref__(ofdm_sync_sc_cfb_sptr self) -> ofdm_sync_sc_cfb"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_sync_sc_cfb_sptr

    def make(self, fft_len: "int", cp_len: "int", use_even_carriers: "bool"=False, threshold: "float"=0.9) -> "gr::digital::ofdm_sync_sc_cfb::sptr":
        r"""make(ofdm_sync_sc_cfb_sptr self, int fft_len, int cp_len, bool use_even_carriers=False, float threshold=0.9) -> ofdm_sync_sc_cfb_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_make(self, fft_len, cp_len, use_even_carriers, threshold)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(ofdm_sync_sc_cfb_sptr self, float threshold)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_threshold(self, threshold)

    def threshold(self) -> "float":
        r"""threshold(ofdm_sync_sc_cfb_sptr self) -> float"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_threshold(self)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr block)
        primitive_connect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr block)
        primitive_disconnect(ofdm_sync_sc_cfb_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(ofdm_sync_sc_cfb_sptr self)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(ofdm_sync_sc_cfb_sptr self)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(ofdm_sync_sc_cfb_sptr self)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(ofdm_sync_sc_cfb_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(ofdm_sync_sc_cfb_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ofdm_sync_sc_cfb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ofdm_sync_sc_cfb_sptr self)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ofdm_sync_sc_cfb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ofdm_sync_sc_cfb_sptr self, std::string level)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ofdm_sync_sc_cfb_sptr self) -> std::string"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(ofdm_sync_sc_cfb_sptr self, int i) -> size_t"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ofdm_sync_sc_cfb_sptr self, size_t max_output_buffer)
        set_max_output_buffer(ofdm_sync_sc_cfb_sptr self, int port, size_t max_output_buffer)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(ofdm_sync_sc_cfb_sptr self, int i) -> size_t"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ofdm_sync_sc_cfb_sptr self, size_t min_output_buffer)
        set_min_output_buffer(ofdm_sync_sc_cfb_sptr self, int port, size_t min_output_buffer)
        """
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(ofdm_sync_sc_cfb_sptr self) -> hier_block2_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(ofdm_sync_sc_cfb_sptr self) -> std::string"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ofdm_sync_sc_cfb_sptr self) -> std::string"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ofdm_sync_sc_cfb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ofdm_sync_sc_cfb_sptr self) -> io_signature_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ofdm_sync_sc_cfb_sptr self) -> long"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ofdm_sync_sc_cfb_sptr self) -> basic_block_sptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ofdm_sync_sc_cfb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ofdm_sync_sc_cfb_sptr self) -> std::string"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ofdm_sync_sc_cfb_sptr self, std::string name)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ofdm_sync_sc_cfb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ofdm_sync_sc_cfb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ofdm_sync_sc_cfb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ofdm_sync_sc_cfb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.ofdm_sync_sc_cfb_sptr_message_subscribers(self, which_port)

# Register ofdm_sync_sc_cfb_sptr in _digital_swig0:
_digital_swig0.ofdm_sync_sc_cfb_sptr_swigregister(ofdm_sync_sc_cfb_sptr)


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

class gmskmod_bc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::cpmmod_bc > 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__(gmskmod_bc_sptr self) -> gmskmod_bc_sptr
        __init__(gmskmod_bc_sptr self, cpmmod_bc p) -> gmskmod_bc_sptr
        """
        _digital_swig0.gmskmod_bc_sptr_swiginit(self, _digital_swig0.new_gmskmod_bc_sptr(*args))

    def __deref__(self) -> "gr::digital::cpmmod_bc *":
        r"""__deref__(gmskmod_bc_sptr self) -> cpmmod_bc"""
        return _digital_swig0.gmskmod_bc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_gmskmod_bc_sptr

    def make(self, type: "gr::analog::cpm::cpm_type", h: "float", samples_per_sym: "int", L: "int", beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make(gmskmod_bc_sptr self, gr::analog::cpm::cpm_type type, float h, int samples_per_sym, int L, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_make(self, type, h, samples_per_sym, L, beta)

    def make_gmskmod_bc(self, samples_per_sym: "int"=2, L: "int"=4, beta: "double"=0.3) -> "gr::digital::cpmmod_bc::sptr":
        r"""make_gmskmod_bc(gmskmod_bc_sptr self, int samples_per_sym=2, int L=4, double beta=0.3) -> cpmmod_bc_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_make_gmskmod_bc(self, samples_per_sym, L, beta)

    def taps(self) -> "std::vector< float,std::allocator< float > >":
        r"""taps(gmskmod_bc_sptr self) -> pmt_vector_float"""
        return _digital_swig0.gmskmod_bc_sptr_taps(self)

    def type(self) -> "int":
        r"""type(gmskmod_bc_sptr self) -> int"""
        return _digital_swig0.gmskmod_bc_sptr_type(self)

    def index(self) -> "float":
        r"""index(gmskmod_bc_sptr self) -> float"""
        return _digital_swig0.gmskmod_bc_sptr_index(self)

    def samples_per_sym(self) -> "int":
        r"""samples_per_sym(gmskmod_bc_sptr self) -> int"""
        return _digital_swig0.gmskmod_bc_sptr_samples_per_sym(self)

    def length(self) -> "int":
        r"""length(gmskmod_bc_sptr self) -> int"""
        return _digital_swig0.gmskmod_bc_sptr_length(self)

    def beta(self) -> "double":
        r"""beta(gmskmod_bc_sptr self) -> double"""
        return _digital_swig0.gmskmod_bc_sptr_beta(self)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(gmskmod_bc_sptr self, basic_block_sptr block)
        primitive_connect(gmskmod_bc_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.gmskmod_bc_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(gmskmod_bc_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(gmskmod_bc_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.gmskmod_bc_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(gmskmod_bc_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(gmskmod_bc_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _digital_swig0.gmskmod_bc_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(gmskmod_bc_sptr self, basic_block_sptr block)
        primitive_disconnect(gmskmod_bc_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _digital_swig0.gmskmod_bc_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(gmskmod_bc_sptr self)"""
        return _digital_swig0.gmskmod_bc_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(gmskmod_bc_sptr self)"""
        return _digital_swig0.gmskmod_bc_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(gmskmod_bc_sptr self)"""
        return _digital_swig0.gmskmod_bc_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(gmskmod_bc_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.gmskmod_bc_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(gmskmod_bc_sptr self, swig_pmt_ptr port_id)"""
        return _digital_swig0.gmskmod_bc_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(gmskmod_bc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig0.gmskmod_bc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(gmskmod_bc_sptr self)"""
        return _digital_swig0.gmskmod_bc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(gmskmod_bc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.gmskmod_bc_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(gmskmod_bc_sptr self, std::string level)"""
        return _digital_swig0.gmskmod_bc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(gmskmod_bc_sptr self) -> std::string"""
        return _digital_swig0.gmskmod_bc_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(gmskmod_bc_sptr self, int i) -> size_t"""
        return _digital_swig0.gmskmod_bc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(gmskmod_bc_sptr self, size_t max_output_buffer)
        set_max_output_buffer(gmskmod_bc_sptr self, int port, size_t max_output_buffer)
        """
        return _digital_swig0.gmskmod_bc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(gmskmod_bc_sptr self, int i) -> size_t"""
        return _digital_swig0.gmskmod_bc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(gmskmod_bc_sptr self, size_t min_output_buffer)
        set_min_output_buffer(gmskmod_bc_sptr self, int port, size_t min_output_buffer)
        """
        return _digital_swig0.gmskmod_bc_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(gmskmod_bc_sptr self) -> hier_block2_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(gmskmod_bc_sptr self) -> std::string"""
        return _digital_swig0.gmskmod_bc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(gmskmod_bc_sptr self) -> std::string"""
        return _digital_swig0.gmskmod_bc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(gmskmod_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(gmskmod_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(gmskmod_bc_sptr self) -> long"""
        return _digital_swig0.gmskmod_bc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(gmskmod_bc_sptr self) -> basic_block_sptr"""
        return _digital_swig0.gmskmod_bc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(gmskmod_bc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig0.gmskmod_bc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(gmskmod_bc_sptr self) -> std::string"""
        return _digital_swig0.gmskmod_bc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(gmskmod_bc_sptr self, std::string name)"""
        return _digital_swig0.gmskmod_bc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(gmskmod_bc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig0.gmskmod_bc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(gmskmod_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.gmskmod_bc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(gmskmod_bc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.gmskmod_bc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(gmskmod_bc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig0.gmskmod_bc_sptr_message_subscribers(self, which_port)

# Register gmskmod_bc_sptr in _digital_swig0:
_digital_swig0.gmskmod_bc_sptr_swigregister(gmskmod_bc_sptr)


gmskmod_bc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
gmskmod_bc = cpmmod_bc_make_gmskmod_bc;

class constellation_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation > 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__(constellation_sptr self) -> constellation_sptr
        __init__(constellation_sptr self, constellation p) -> constellation_sptr
        """
        _digital_swig0.constellation_sptr_swiginit(self, _digital_swig0.new_constellation_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation *":
        r"""__deref__(constellation_sptr self) -> constellation"""
        return _digital_swig0.constellation_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_sptr

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_sptr self) -> bool"""
        return _digital_swig0.constellation_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_sptr self, bool a)"""
        return _digital_swig0.constellation_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_sptr self) -> bool"""
        return _digital_swig0.constellation_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_sptr_soft_decision_maker(self, sample)

# Register constellation_sptr in _digital_swig0:
_digital_swig0.constellation_sptr_swigregister(constellation_sptr)

class constellation_calcdist_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_calcdist > 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__(constellation_calcdist_sptr self) -> constellation_calcdist_sptr
        __init__(constellation_calcdist_sptr self, constellation_calcdist p) -> constellation_calcdist_sptr
        """
        _digital_swig0.constellation_calcdist_sptr_swiginit(self, _digital_swig0.new_constellation_calcdist_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_calcdist *":
        r"""__deref__(constellation_calcdist_sptr self) -> constellation_calcdist"""
        return _digital_swig0.constellation_calcdist_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_calcdist_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
        r"""make(constellation_calcdist_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _digital_swig0.constellation_calcdist_sptr_make(self, constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_calcdist_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_calcdist_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_calcdist_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_calcdist_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_calcdist_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_calcdist_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_calcdist_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_calcdist_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_calcdist_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_calcdist_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_calcdist_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_calcdist_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_calcdist_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_calcdist_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_calcdist_sptr self) -> bool"""
        return _digital_swig0.constellation_calcdist_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_calcdist_sptr self, bool a)"""
        return _digital_swig0.constellation_calcdist_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_calcdist_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_calcdist_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_calcdist_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_calcdist_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_calcdist_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_calcdist_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_calcdist_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_calcdist_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_calcdist_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_calcdist_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_calcdist_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_calcdist_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_calcdist_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_calcdist_sptr self) -> bool"""
        return _digital_swig0.constellation_calcdist_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_calcdist_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_calcdist_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_calcdist_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_calcdist_sptr_soft_decision_maker(self, sample)

# Register constellation_calcdist_sptr in _digital_swig0:
_digital_swig0.constellation_calcdist_sptr_swigregister(constellation_calcdist_sptr)


constellation_calcdist_sptr.__repr__ = lambda self: "<constellation calcdist (m=%d)>" % (len(self.points()))
constellation_calcdist = constellation_calcdist.make;

class constellation_rect_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_rect > 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__(constellation_rect_sptr self) -> constellation_rect_sptr
        __init__(constellation_rect_sptr self, constellation_rect p) -> constellation_rect_sptr
        """
        _digital_swig0.constellation_rect_sptr_swiginit(self, _digital_swig0.new_constellation_rect_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_rect *":
        r"""__deref__(constellation_rect_sptr self) -> constellation_rect"""
        return _digital_swig0.constellation_rect_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_rect_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
        r"""make(constellation_rect_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _digital_swig0.constellation_rect_sptr_make(self, constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_rect_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_rect_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_rect_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_rect_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_rect_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_rect_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_rect_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_rect_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_rect_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_rect_sptr self) -> bool"""
        return _digital_swig0.constellation_rect_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_rect_sptr self, bool a)"""
        return _digital_swig0.constellation_rect_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_rect_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_rect_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_rect_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_rect_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_rect_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_rect_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_rect_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_rect_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_rect_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_rect_sptr self) -> bool"""
        return _digital_swig0.constellation_rect_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_rect_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_rect_sptr_soft_decision_maker(self, sample)

# Register constellation_rect_sptr in _digital_swig0:
_digital_swig0.constellation_rect_sptr_swigregister(constellation_rect_sptr)


constellation_rect_sptr.__repr__ = lambda self: "<constellation rect (m=%d)>" % (len(self.points()))
constellation_rect = constellation_rect.make;

class constellation_expl_rect_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_expl_rect > 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__(constellation_expl_rect_sptr self) -> constellation_expl_rect_sptr
        __init__(constellation_expl_rect_sptr self, constellation_expl_rect p) -> constellation_expl_rect_sptr
        """
        _digital_swig0.constellation_expl_rect_sptr_swiginit(self, _digital_swig0.new_constellation_expl_rect_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_expl_rect *":
        r"""__deref__(constellation_expl_rect_sptr self) -> constellation_expl_rect"""
        return _digital_swig0.constellation_expl_rect_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_expl_rect_sptr

    def make(self, constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
        r"""make(constellation_expl_rect_sptr self, pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _digital_swig0.constellation_expl_rect_sptr_make(self, constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_expl_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_expl_rect_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_expl_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_expl_rect_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_expl_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_expl_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_expl_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_expl_rect_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_expl_rect_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_expl_rect_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_expl_rect_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_expl_rect_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_expl_rect_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_expl_rect_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_expl_rect_sptr self) -> bool"""
        return _digital_swig0.constellation_expl_rect_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_expl_rect_sptr self, bool a)"""
        return _digital_swig0.constellation_expl_rect_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_expl_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_expl_rect_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_expl_rect_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_expl_rect_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_expl_rect_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_expl_rect_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_expl_rect_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_expl_rect_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_expl_rect_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_expl_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_expl_rect_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_expl_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_expl_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_expl_rect_sptr self) -> bool"""
        return _digital_swig0.constellation_expl_rect_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_expl_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_expl_rect_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_expl_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_expl_rect_sptr_soft_decision_maker(self, sample)

# Register constellation_expl_rect_sptr in _digital_swig0:
_digital_swig0.constellation_expl_rect_sptr_swigregister(constellation_expl_rect_sptr)


constellation_expl_rect_sptr.__repr__ = lambda self: "<constellation expl rect (m=%d)>" % (len(self.points()))
constellation_expl_rect = constellation_expl_rect.make;

class constellation_psk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_psk > 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__(constellation_psk_sptr self) -> constellation_psk_sptr
        __init__(constellation_psk_sptr self, constellation_psk p) -> constellation_psk_sptr
        """
        _digital_swig0.constellation_psk_sptr_swiginit(self, _digital_swig0.new_constellation_psk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_psk *":
        r"""__deref__(constellation_psk_sptr self) -> constellation_psk"""
        return _digital_swig0.constellation_psk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_psk_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
        r"""make(constellation_psk_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _digital_swig0.constellation_psk_sptr_make(self, constell, pre_diff_code, n_sectors)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_psk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_psk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_psk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_psk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_psk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_psk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_psk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_psk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_psk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_psk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_psk_sptr self) -> bool"""
        return _digital_swig0.constellation_psk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_psk_sptr self, bool a)"""
        return _digital_swig0.constellation_psk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_psk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_psk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_psk_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_psk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_psk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_psk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_psk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_psk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_psk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_psk_sptr self) -> bool"""
        return _digital_swig0.constellation_psk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_psk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_psk_sptr_soft_decision_maker(self, sample)

# Register constellation_psk_sptr in _digital_swig0:
_digital_swig0.constellation_psk_sptr_swigregister(constellation_psk_sptr)


constellation_psk_sptr.__repr__ = lambda self: "<constellation PSK (m=%d)>" % (len(self.points()))
constellation_psk = constellation_psk.make;

class constellation_bpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_bpsk > 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__(constellation_bpsk_sptr self) -> constellation_bpsk_sptr
        __init__(constellation_bpsk_sptr self, constellation_bpsk p) -> constellation_bpsk_sptr
        """
        _digital_swig0.constellation_bpsk_sptr_swiginit(self, _digital_swig0.new_constellation_bpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_bpsk *":
        r"""__deref__(constellation_bpsk_sptr self) -> constellation_bpsk"""
        return _digital_swig0.constellation_bpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_bpsk_sptr

    def make(self) -> "gr::digital::constellation_bpsk::sptr":
        r"""make(constellation_bpsk_sptr self) -> constellation_bpsk_sptr"""
        return _digital_swig0.constellation_bpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_bpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_bpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_bpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_bpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_bpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_bpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_bpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_bpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_bpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_bpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_bpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_bpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_bpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_bpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_bpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_bpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_bpsk_sptr self, bool a)"""
        return _digital_swig0.constellation_bpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_bpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_bpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_bpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_bpsk_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_bpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_bpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_bpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_bpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_bpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_bpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_bpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_bpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_bpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_bpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_bpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_bpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_bpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_bpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_bpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_bpsk_sptr in _digital_swig0:
_digital_swig0.constellation_bpsk_sptr_swigregister(constellation_bpsk_sptr)


constellation_bpsk_sptr.__repr__ = lambda self: "<constellation BPSK>"
constellation_bpsk = constellation_bpsk.make;

class constellation_qpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_qpsk > 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__(constellation_qpsk_sptr self) -> constellation_qpsk_sptr
        __init__(constellation_qpsk_sptr self, constellation_qpsk p) -> constellation_qpsk_sptr
        """
        _digital_swig0.constellation_qpsk_sptr_swiginit(self, _digital_swig0.new_constellation_qpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_qpsk *":
        r"""__deref__(constellation_qpsk_sptr self) -> constellation_qpsk"""
        return _digital_swig0.constellation_qpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_qpsk_sptr

    def make(self) -> "gr::digital::constellation_qpsk::sptr":
        r"""make(constellation_qpsk_sptr self) -> constellation_qpsk_sptr"""
        return _digital_swig0.constellation_qpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_qpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_qpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_qpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_qpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_qpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_qpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_qpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_qpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_qpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_qpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_qpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_qpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_qpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_qpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_qpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_qpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_qpsk_sptr self, bool a)"""
        return _digital_swig0.constellation_qpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_qpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_qpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_qpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_qpsk_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_qpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_qpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_qpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_qpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_qpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_qpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_qpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_qpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_qpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_qpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_qpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_qpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_qpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_qpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_qpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_qpsk_sptr in _digital_swig0:
_digital_swig0.constellation_qpsk_sptr_swigregister(constellation_qpsk_sptr)


constellation_qpsk_sptr.__repr__ = lambda self: "<constellation QPSK>"
constellation_qpsk = constellation_qpsk.make;

class constellation_dqpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_dqpsk > 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__(constellation_dqpsk_sptr self) -> constellation_dqpsk_sptr
        __init__(constellation_dqpsk_sptr self, constellation_dqpsk p) -> constellation_dqpsk_sptr
        """
        _digital_swig0.constellation_dqpsk_sptr_swiginit(self, _digital_swig0.new_constellation_dqpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_dqpsk *":
        r"""__deref__(constellation_dqpsk_sptr self) -> constellation_dqpsk"""
        return _digital_swig0.constellation_dqpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_dqpsk_sptr

    def make(self) -> "gr::digital::constellation_dqpsk::sptr":
        r"""make(constellation_dqpsk_sptr self) -> constellation_dqpsk_sptr"""
        return _digital_swig0.constellation_dqpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_dqpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_dqpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_dqpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_dqpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_dqpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_dqpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_dqpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_dqpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_dqpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_dqpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_dqpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_dqpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_dqpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_dqpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_dqpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_dqpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_dqpsk_sptr self, bool a)"""
        return _digital_swig0.constellation_dqpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_dqpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_dqpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_dqpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_dqpsk_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_dqpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_dqpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_dqpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_dqpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_dqpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_dqpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_dqpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_dqpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_dqpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_dqpsk_sptr self) -> bool"""
        return _digital_swig0.constellation_dqpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_dqpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_dqpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_dqpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_dqpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_dqpsk_sptr in _digital_swig0:
_digital_swig0.constellation_dqpsk_sptr_swigregister(constellation_dqpsk_sptr)


constellation_dqpsk_sptr.__repr__ = lambda self: "<constellation DQPSK>"
constellation_dqpsk = constellation_dqpsk.make;

class constellation_8psk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_8psk > 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__(constellation_8psk_sptr self) -> constellation_8psk_sptr
        __init__(constellation_8psk_sptr self, constellation_8psk p) -> constellation_8psk_sptr
        """
        _digital_swig0.constellation_8psk_sptr_swiginit(self, _digital_swig0.new_constellation_8psk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_8psk *":
        r"""__deref__(constellation_8psk_sptr self) -> constellation_8psk"""
        return _digital_swig0.constellation_8psk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_8psk_sptr

    def make(self) -> "gr::digital::constellation_8psk::sptr":
        r"""make(constellation_8psk_sptr self) -> constellation_8psk_sptr"""
        return _digital_swig0.constellation_8psk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_8psk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_8psk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_8psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_8psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_8psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_8psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_8psk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_8psk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_8psk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_8psk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_8psk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_8psk_sptr self) -> bool"""
        return _digital_swig0.constellation_8psk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_8psk_sptr self, bool a)"""
        return _digital_swig0.constellation_8psk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_8psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_8psk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_8psk_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_8psk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_8psk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_8psk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_8psk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_8psk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_8psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_8psk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_8psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_8psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_8psk_sptr self) -> bool"""
        return _digital_swig0.constellation_8psk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_8psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_8psk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_8psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_8psk_sptr_soft_decision_maker(self, sample)

# Register constellation_8psk_sptr in _digital_swig0:
_digital_swig0.constellation_8psk_sptr_swigregister(constellation_8psk_sptr)


constellation_8psk_sptr.__repr__ = lambda self: "<constellation 8PSK>"
constellation_8psk = constellation_8psk.make;

class constellation_8psk_natural_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_8psk_natural > 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__(constellation_8psk_natural_sptr self) -> constellation_8psk_natural_sptr
        __init__(constellation_8psk_natural_sptr self, constellation_8psk_natural p) -> constellation_8psk_natural_sptr
        """
        _digital_swig0.constellation_8psk_natural_sptr_swiginit(self, _digital_swig0.new_constellation_8psk_natural_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_8psk_natural *":
        r"""__deref__(constellation_8psk_natural_sptr self) -> constellation_8psk_natural"""
        return _digital_swig0.constellation_8psk_natural_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_8psk_natural_sptr

    def make(self) -> "gr::digital::constellation_8psk_natural::sptr":
        r"""make(constellation_8psk_natural_sptr self) -> constellation_8psk_natural_sptr"""
        return _digital_swig0.constellation_8psk_natural_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_8psk_natural_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_8psk_natural_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_8psk_natural_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_natural_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_8psk_natural_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_8psk_natural_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_8psk_natural_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_8psk_natural_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_8psk_natural_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_8psk_natural_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_natural_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_8psk_natural_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_8psk_natural_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_8psk_natural_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_8psk_natural_sptr self) -> bool"""
        return _digital_swig0.constellation_8psk_natural_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_8psk_natural_sptr self, bool a)"""
        return _digital_swig0.constellation_8psk_natural_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_8psk_natural_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_8psk_natural_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_8psk_natural_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_8psk_natural_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_8psk_natural_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_8psk_natural_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_8psk_natural_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_8psk_natural_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_8psk_natural_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_8psk_natural_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_8psk_natural_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_8psk_natural_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_8psk_natural_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_8psk_natural_sptr self) -> bool"""
        return _digital_swig0.constellation_8psk_natural_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_8psk_natural_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_8psk_natural_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_8psk_natural_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_8psk_natural_sptr_soft_decision_maker(self, sample)

# Register constellation_8psk_natural_sptr in _digital_swig0:
_digital_swig0.constellation_8psk_natural_sptr_swigregister(constellation_8psk_natural_sptr)


constellation_8psk_natural_sptr.__repr__ = lambda self: "<constellation 8PSK_natural>"
constellation_8psk_natural = constellation_8psk_natural.make;

class constellation_16qam_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_16qam > 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__(constellation_16qam_sptr self) -> constellation_16qam_sptr
        __init__(constellation_16qam_sptr self, constellation_16qam p) -> constellation_16qam_sptr
        """
        _digital_swig0.constellation_16qam_sptr_swiginit(self, _digital_swig0.new_constellation_16qam_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_16qam *":
        r"""__deref__(constellation_16qam_sptr self) -> constellation_16qam"""
        return _digital_swig0.constellation_16qam_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_constellation_16qam_sptr

    def make(self) -> "gr::digital::constellation_16qam::sptr":
        r"""make(constellation_16qam_sptr self) -> constellation_16qam_sptr"""
        return _digital_swig0.constellation_16qam_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_16qam_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig0.constellation_16qam_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_16qam_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_16qam_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_16qam_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_16qam_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_16qam_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig0.constellation_16qam_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_16qam_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig0.constellation_16qam_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_16qam_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig0.constellation_16qam_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_16qam_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig0.constellation_16qam_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_16qam_sptr self) -> bool"""
        return _digital_swig0.constellation_16qam_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_16qam_sptr self, bool a)"""
        return _digital_swig0.constellation_16qam_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_16qam_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig0.constellation_16qam_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig0.constellation_16qam_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_16qam_sptr self) -> constellation_sptr"""
        return _digital_swig0.constellation_16qam_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_16qam_sptr self) -> swig_pmt_ptr"""
        return _digital_swig0.constellation_16qam_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_16qam_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig0.constellation_16qam_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_16qam_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig0.constellation_16qam_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_16qam_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig0.constellation_16qam_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_16qam_sptr self) -> bool"""
        return _digital_swig0.constellation_16qam_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_16qam_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig0.constellation_16qam_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_16qam_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig0.constellation_16qam_sptr_soft_decision_maker(self, sample)

# Register constellation_16qam_sptr in _digital_swig0:
_digital_swig0.constellation_16qam_sptr_swigregister(constellation_16qam_sptr)


constellation_16qam_sptr.__repr__ = lambda self: "<constellation 16qam>"
constellation_16qam = constellation_16qam.make;

class ofdm_equalizer_base_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_equalizer_base > 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__(ofdm_equalizer_base_sptr self) -> ofdm_equalizer_base_sptr
        __init__(ofdm_equalizer_base_sptr self, ofdm_equalizer_base p) -> ofdm_equalizer_base_sptr
        """
        _digital_swig0.ofdm_equalizer_base_sptr_swiginit(self, _digital_swig0.new_ofdm_equalizer_base_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_equalizer_base *":
        r"""__deref__(ofdm_equalizer_base_sptr self) -> ofdm_equalizer_base"""
        return _digital_swig0.ofdm_equalizer_base_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_base_sptr

    def reset(self) -> "void":
        r"""reset(ofdm_equalizer_base_sptr self)"""
        return _digital_swig0.ofdm_equalizer_base_sptr_reset(self)

    def equalize(self, *args, **kwargs) -> "void":
        r"""equalize(ofdm_equalizer_base_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())"""
        return _digital_swig0.ofdm_equalizer_base_sptr_equalize(self, *args, **kwargs)

    def get_channel_state(self, taps: "pmt_vector_cfloat") -> "void":
        r"""get_channel_state(ofdm_equalizer_base_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.ofdm_equalizer_base_sptr_get_channel_state(self, taps)

    def fft_len(self) -> "int":
        r"""fft_len(ofdm_equalizer_base_sptr self) -> int"""
        return _digital_swig0.ofdm_equalizer_base_sptr_fft_len(self)

    def base(self) -> "gr::digital::ofdm_equalizer_base::sptr":
        r"""base(ofdm_equalizer_base_sptr self) -> ofdm_equalizer_base_sptr"""
        return _digital_swig0.ofdm_equalizer_base_sptr_base(self)

# Register ofdm_equalizer_base_sptr in _digital_swig0:
_digital_swig0.ofdm_equalizer_base_sptr_swigregister(ofdm_equalizer_base_sptr)

class ofdm_equalizer_1d_pilots_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_equalizer_1d_pilots > 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__(ofdm_equalizer_1d_pilots_sptr self) -> ofdm_equalizer_1d_pilots_sptr
        __init__(ofdm_equalizer_1d_pilots_sptr self, ofdm_equalizer_1d_pilots p) -> ofdm_equalizer_1d_pilots_sptr
        """
        _digital_swig0.ofdm_equalizer_1d_pilots_sptr_swiginit(self, _digital_swig0.new_ofdm_equalizer_1d_pilots_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_equalizer_1d_pilots *":
        r"""__deref__(ofdm_equalizer_1d_pilots_sptr self) -> ofdm_equalizer_1d_pilots"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_1d_pilots_sptr

    def reset(self) -> "void":
        r"""reset(ofdm_equalizer_1d_pilots_sptr self)"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr_reset(self)

    def equalize(self, *args, **kwargs) -> "void":
        r"""equalize(ofdm_equalizer_1d_pilots_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr_equalize(self, *args, **kwargs)

    def get_channel_state(self, taps: "pmt_vector_cfloat") -> "void":
        r"""get_channel_state(ofdm_equalizer_1d_pilots_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr_get_channel_state(self, taps)

    def fft_len(self) -> "int":
        r"""fft_len(ofdm_equalizer_1d_pilots_sptr self) -> int"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr_fft_len(self)

    def base(self) -> "gr::digital::ofdm_equalizer_base::sptr":
        r"""base(ofdm_equalizer_1d_pilots_sptr self) -> ofdm_equalizer_base_sptr"""
        return _digital_swig0.ofdm_equalizer_1d_pilots_sptr_base(self)

# Register ofdm_equalizer_1d_pilots_sptr in _digital_swig0:
_digital_swig0.ofdm_equalizer_1d_pilots_sptr_swigregister(ofdm_equalizer_1d_pilots_sptr)


ofdm_equalizer_1d_pilots_sptr.__repr__ = lambda self: "<OFDM equalizer 1D base class>"

class ofdm_equalizer_simpledfe_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_equalizer_simpledfe > 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__(ofdm_equalizer_simpledfe_sptr self) -> ofdm_equalizer_simpledfe_sptr
        __init__(ofdm_equalizer_simpledfe_sptr self, ofdm_equalizer_simpledfe p) -> ofdm_equalizer_simpledfe_sptr
        """
        _digital_swig0.ofdm_equalizer_simpledfe_sptr_swiginit(self, _digital_swig0.new_ofdm_equalizer_simpledfe_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_equalizer_simpledfe *":
        r"""__deref__(ofdm_equalizer_simpledfe_sptr self) -> ofdm_equalizer_simpledfe"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_simpledfe_sptr

    def make(self, *args, **kwargs) -> "gr::digital::ofdm_equalizer_simpledfe::sptr":
        r"""make(ofdm_equalizer_simpledfe_sptr self, int fft_len, constellation_sptr constellation, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=True) -> ofdm_equalizer_simpledfe_sptr"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_make(self, *args, **kwargs)

    def reset(self) -> "void":
        r"""reset(ofdm_equalizer_simpledfe_sptr self)"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_reset(self)

    def equalize(self, *args, **kwargs) -> "void":
        r"""equalize(ofdm_equalizer_simpledfe_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_equalize(self, *args, **kwargs)

    def get_channel_state(self, taps: "pmt_vector_cfloat") -> "void":
        r"""get_channel_state(ofdm_equalizer_simpledfe_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_get_channel_state(self, taps)

    def fft_len(self) -> "int":
        r"""fft_len(ofdm_equalizer_simpledfe_sptr self) -> int"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_fft_len(self)

    def base(self) -> "gr::digital::ofdm_equalizer_base::sptr":
        r"""base(ofdm_equalizer_simpledfe_sptr self) -> ofdm_equalizer_base_sptr"""
        return _digital_swig0.ofdm_equalizer_simpledfe_sptr_base(self)

# Register ofdm_equalizer_simpledfe_sptr in _digital_swig0:
_digital_swig0.ofdm_equalizer_simpledfe_sptr_swigregister(ofdm_equalizer_simpledfe_sptr)


ofdm_equalizer_simpledfe_sptr.__repr__ = lambda self: "<OFDM equalizer simpledfe>"
ofdm_equalizer_simpledfe = ofdm_equalizer_simpledfe.make;

class ofdm_equalizer_static_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::ofdm_equalizer_static > 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__(ofdm_equalizer_static_sptr self) -> ofdm_equalizer_static_sptr
        __init__(ofdm_equalizer_static_sptr self, ofdm_equalizer_static p) -> ofdm_equalizer_static_sptr
        """
        _digital_swig0.ofdm_equalizer_static_sptr_swiginit(self, _digital_swig0.new_ofdm_equalizer_static_sptr(*args))

    def __deref__(self) -> "gr::digital::ofdm_equalizer_static *":
        r"""__deref__(ofdm_equalizer_static_sptr self) -> ofdm_equalizer_static"""
        return _digital_swig0.ofdm_equalizer_static_sptr___deref__(self)
    __swig_destroy__ = _digital_swig0.delete_ofdm_equalizer_static_sptr

    def make(self, *args, **kwargs) -> "gr::digital::ofdm_equalizer_static::sptr":
        r"""make(ofdm_equalizer_static_sptr self, int fft_len, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, bool input_is_shifted=True) -> ofdm_equalizer_static_sptr"""
        return _digital_swig0.ofdm_equalizer_static_sptr_make(self, *args, **kwargs)

    def reset(self) -> "void":
        r"""reset(ofdm_equalizer_static_sptr self)"""
        return _digital_swig0.ofdm_equalizer_static_sptr_reset(self)

    def equalize(self, *args, **kwargs) -> "void":
        r"""equalize(ofdm_equalizer_static_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())"""
        return _digital_swig0.ofdm_equalizer_static_sptr_equalize(self, *args, **kwargs)

    def get_channel_state(self, taps: "pmt_vector_cfloat") -> "void":
        r"""get_channel_state(ofdm_equalizer_static_sptr self, pmt_vector_cfloat taps)"""
        return _digital_swig0.ofdm_equalizer_static_sptr_get_channel_state(self, taps)

    def fft_len(self) -> "int":
        r"""fft_len(ofdm_equalizer_static_sptr self) -> int"""
        return _digital_swig0.ofdm_equalizer_static_sptr_fft_len(self)

    def base(self) -> "gr::digital::ofdm_equalizer_base::sptr":
        r"""base(ofdm_equalizer_static_sptr self) -> ofdm_equalizer_base_sptr"""
        return _digital_swig0.ofdm_equalizer_static_sptr_base(self)

# Register ofdm_equalizer_static_sptr in _digital_swig0:
_digital_swig0.ofdm_equalizer_static_sptr_swigregister(ofdm_equalizer_static_sptr)


ofdm_equalizer_static_sptr.__repr__ = lambda self: "<OFDM equalizer static>"
ofdm_equalizer_static = ofdm_equalizer_static.make;



