# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_digital_swig1')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_digital_swig1')
    _digital_swig1 = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_digital_swig1', [dirname(__file__)])
        except ImportError:
            import _digital_swig1
            return _digital_swig1
        try:
            _mod = imp.load_module('_digital_swig1', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _digital_swig1 = swig_import_helper()
    del swig_import_helper
else:
    import _digital_swig1
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def high_res_timer_now():
    """high_res_timer_now() -> gr::high_res_timer_type"""
    return _digital_swig1.high_res_timer_now()

def high_res_timer_now_perfmon():
    """high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _digital_swig1.high_res_timer_now_perfmon()

def high_res_timer_tps():
    """high_res_timer_tps() -> gr::high_res_timer_type"""
    return _digital_swig1.high_res_timer_tps()

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _digital_swig1.high_res_timer_epoch()
class control_loop(object):
    """Proxy of C++ gr::blocks::control_loop class."""

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

    def __init__(self, *args):
        """
        __init__(gr::blocks::control_loop self) -> control_loop
        __init__(gr::blocks::control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        this = _digital_swig1.new_control_loop(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig1.delete_control_loop
    __del__ = lambda self: None

    def update_gains(self):
        """update_gains(control_loop self)"""
        return _digital_swig1.control_loop_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(control_loop self, float error)"""
        return _digital_swig1.control_loop_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(control_loop self)"""
        return _digital_swig1.control_loop_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(control_loop self)"""
        return _digital_swig1.control_loop_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(control_loop self, float bw)"""
        return _digital_swig1.control_loop_set_loop_bandwidth(self, bw)


    def set_damping_factor(self, df):
        """set_damping_factor(control_loop self, float df)"""
        return _digital_swig1.control_loop_set_damping_factor(self, df)


    def set_alpha(self, alpha):
        """set_alpha(control_loop self, float alpha)"""
        return _digital_swig1.control_loop_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(control_loop self, float beta)"""
        return _digital_swig1.control_loop_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(control_loop self, float phase)"""
        return _digital_swig1.control_loop_set_phase(self, phase)


    def set_max_freq(self, freq):
        """set_max_freq(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_max_freq(self, freq)


    def set_min_freq(self, freq):
        """set_min_freq(control_loop self, float freq)"""
        return _digital_swig1.control_loop_set_min_freq(self, freq)


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


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


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


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


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


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


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


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

control_loop_swigregister = _digital_swig1.control_loop_swigregister
control_loop_swigregister(control_loop)


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

    thisown = _swig_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 make(*args, **kwargs):
        """make(int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key) -> additive_scrambler_bb_sptr"""
        return _digital_swig1.additive_scrambler_bb_make(*args, **kwargs)

    make = staticmethod(make)

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


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


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


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


    def bits_per_byte(self):
        """bits_per_byte(additive_scrambler_bb self) -> int"""
        return _digital_swig1.additive_scrambler_bb_bits_per_byte(self)

    __swig_destroy__ = _digital_swig1.delete_additive_scrambler_bb
    __del__ = lambda self: None
additive_scrambler_bb_swigregister = _digital_swig1.additive_scrambler_bb_swigregister
additive_scrambler_bb_swigregister(additive_scrambler_bb)
cvar = _digital_swig1.cvar

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

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

    thisown = _swig_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 make(*args, **kwargs):
        """make(pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name) -> burst_shaper_cc_sptr"""
        return _digital_swig1.burst_shaper_cc_make(*args, **kwargs)

    make = staticmethod(make)

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


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


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


    def suffix_length(self):
        """suffix_length(burst_shaper_cc self) -> int"""
        return _digital_swig1.burst_shaper_cc_suffix_length(self)

    __swig_destroy__ = _digital_swig1.delete_burst_shaper_cc
    __del__ = lambda self: None
burst_shaper_cc_swigregister = _digital_swig1.burst_shaper_cc_swigregister
burst_shaper_cc_swigregister(burst_shaper_cc)

def burst_shaper_cc_make(*args, **kwargs):
    """burst_shaper_cc_make(pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name) -> burst_shaper_cc_sptr"""
    return _digital_swig1.burst_shaper_cc_make(*args, **kwargs)

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

    thisown = _swig_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 make(*args, **kwargs):
        """make(pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name) -> burst_shaper_ff_sptr"""
        return _digital_swig1.burst_shaper_ff_make(*args, **kwargs)

    make = staticmethod(make)

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


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


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


    def suffix_length(self):
        """suffix_length(burst_shaper_ff self) -> int"""
        return _digital_swig1.burst_shaper_ff_suffix_length(self)

    __swig_destroy__ = _digital_swig1.delete_burst_shaper_ff
    __del__ = lambda self: None
burst_shaper_ff_swigregister = _digital_swig1.burst_shaper_ff_swigregister
burst_shaper_ff_swigregister(burst_shaper_ff)

def burst_shaper_ff_make(*args, **kwargs):
    """burst_shaper_ff_make(pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name) -> burst_shaper_ff_sptr"""
    return _digital_swig1.burst_shaper_ff_make(*args, **kwargs)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_bc self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_bc_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_bc self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bc_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bc
    __del__ = lambda self: None
chunks_to_symbols_bc_swigregister = _digital_swig1.chunks_to_symbols_bc_swigregister
chunks_to_symbols_bc_swigregister(chunks_to_symbols_bc)

def chunks_to_symbols_bc_make(symbol_table, D=1):
    """chunks_to_symbols_bc_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
    return _digital_swig1.chunks_to_symbols_bc_make(symbol_table, D)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_bf self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_bf_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_bf self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bf_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bf
    __del__ = lambda self: None
chunks_to_symbols_bf_swigregister = _digital_swig1.chunks_to_symbols_bf_swigregister
chunks_to_symbols_bf_swigregister(chunks_to_symbols_bf)

def chunks_to_symbols_bf_make(symbol_table, D=1):
    """chunks_to_symbols_bf_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
    return _digital_swig1.chunks_to_symbols_bf_make(symbol_table, D)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_ic self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_ic_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_ic self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_ic_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_ic
    __del__ = lambda self: None
chunks_to_symbols_ic_swigregister = _digital_swig1.chunks_to_symbols_ic_swigregister
chunks_to_symbols_ic_swigregister(chunks_to_symbols_ic)

def chunks_to_symbols_ic_make(symbol_table, D=1):
    """chunks_to_symbols_ic_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
    return _digital_swig1.chunks_to_symbols_ic_make(symbol_table, D)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
        return _digital_swig1.chunks_to_symbols_if_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_if self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_if_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_if self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_if_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_if
    __del__ = lambda self: None
chunks_to_symbols_if_swigregister = _digital_swig1.chunks_to_symbols_if_swigregister
chunks_to_symbols_if_swigregister(chunks_to_symbols_if)

def chunks_to_symbols_if_make(symbol_table, D=1):
    """chunks_to_symbols_if_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
    return _digital_swig1.chunks_to_symbols_if_make(symbol_table, D)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_sc self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_sc_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_sc self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sc_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sc
    __del__ = lambda self: None
chunks_to_symbols_sc_swigregister = _digital_swig1.chunks_to_symbols_sc_swigregister
chunks_to_symbols_sc_swigregister(chunks_to_symbols_sc)

def chunks_to_symbols_sc_make(symbol_table, D=1):
    """chunks_to_symbols_sc_make(pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
    return _digital_swig1.chunks_to_symbols_sc_make(symbol_table, D)

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

    thisown = _swig_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 make(symbol_table, D=1):
        """make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_make(symbol_table, D)

    make = staticmethod(make)

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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_sf self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_sf_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_sf self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sf_set_symbol_table(self, symbol_table)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sf
    __del__ = lambda self: None
chunks_to_symbols_sf_swigregister = _digital_swig1.chunks_to_symbols_sf_swigregister
chunks_to_symbols_sf_swigregister(chunks_to_symbols_sf)

def chunks_to_symbols_sf_make(symbol_table, D=1):
    """chunks_to_symbols_sf_make(pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
    return _digital_swig1.chunks_to_symbols_sf_make(symbol_table, D)

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

    thisown = _swig_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 make(omega, gain_omega, mu, gain_mu, omega_relative_limit):
        """make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

    make = staticmethod(make)

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


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


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


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


    def set_verbose(self, verbose):
        """set_verbose(clock_recovery_mm_cc self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_cc_set_verbose(self, verbose)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(clock_recovery_mm_cc self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_cc_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(clock_recovery_mm_cc self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_cc_set_gain_omega(self, gain_omega)


    def set_mu(self, mu):
        """set_mu(clock_recovery_mm_cc self, float mu)"""
        return _digital_swig1.clock_recovery_mm_cc_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(clock_recovery_mm_cc self, float omega)"""
        return _digital_swig1.clock_recovery_mm_cc_set_omega(self, omega)

    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_cc
    __del__ = lambda self: None
clock_recovery_mm_cc_swigregister = _digital_swig1.clock_recovery_mm_cc_swigregister
clock_recovery_mm_cc_swigregister(clock_recovery_mm_cc)

def clock_recovery_mm_cc_make(omega, gain_omega, mu, gain_mu, omega_relative_limit):
    """clock_recovery_mm_cc_make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
    return _digital_swig1.clock_recovery_mm_cc_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

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

    thisown = _swig_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 make(omega, gain_omega, mu, gain_mu, omega_relative_limit):
        """make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

    make = staticmethod(make)

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


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


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


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


    def set_verbose(self, verbose):
        """set_verbose(clock_recovery_mm_ff self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_ff_set_verbose(self, verbose)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(clock_recovery_mm_ff self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_ff_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(clock_recovery_mm_ff self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_ff_set_gain_omega(self, gain_omega)


    def set_mu(self, mu):
        """set_mu(clock_recovery_mm_ff self, float mu)"""
        return _digital_swig1.clock_recovery_mm_ff_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(clock_recovery_mm_ff self, float omega)"""
        return _digital_swig1.clock_recovery_mm_ff_set_omega(self, omega)

    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_ff
    __del__ = lambda self: None
clock_recovery_mm_ff_swigregister = _digital_swig1.clock_recovery_mm_ff_swigregister
clock_recovery_mm_ff_swigregister(clock_recovery_mm_ff)

def clock_recovery_mm_ff_make(omega, gain_omega, mu, gain_mu, omega_relative_limit):
    """clock_recovery_mm_ff_make(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
    return _digital_swig1.clock_recovery_mm_ff_make(omega, gain_omega, mu, gain_mu, omega_relative_limit)

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

    thisown = _swig_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

    def make(modulus):
        """make(unsigned int modulus) -> diff_decoder_bb_sptr"""
        return _digital_swig1.diff_decoder_bb_make(modulus)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_diff_decoder_bb
    __del__ = lambda self: None
diff_decoder_bb_swigregister = _digital_swig1.diff_decoder_bb_swigregister
diff_decoder_bb_swigregister(diff_decoder_bb)

def diff_decoder_bb_make(modulus):
    """diff_decoder_bb_make(unsigned int modulus) -> diff_decoder_bb_sptr"""
    return _digital_swig1.diff_decoder_bb_make(modulus)

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

    thisown = _swig_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

    def make(modulus):
        """make(unsigned int modulus) -> diff_encoder_bb_sptr"""
        return _digital_swig1.diff_encoder_bb_make(modulus)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_diff_encoder_bb
    __del__ = lambda self: None
diff_encoder_bb_swigregister = _digital_swig1.diff_encoder_bb_swigregister
diff_encoder_bb_swigregister(diff_encoder_bb)

def diff_encoder_bb_make(modulus):
    """diff_encoder_bb_make(unsigned int modulus) -> diff_encoder_bb_sptr"""
    return _digital_swig1.diff_encoder_bb_make(modulus)

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

    thisown = _swig_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

    def make():
        """make() -> diff_phasor_cc_sptr"""
        return _digital_swig1.diff_phasor_cc_make()

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_diff_phasor_cc
    __del__ = lambda self: None
diff_phasor_cc_swigregister = _digital_swig1.diff_phasor_cc_swigregister
diff_phasor_cc_swigregister(diff_phasor_cc)

def diff_phasor_cc_make():
    """diff_phasor_cc_make() -> diff_phasor_cc_sptr"""
    return _digital_swig1.diff_phasor_cc_make()

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

    thisown = _swig_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 make(samps_per_sym, rolloff, filter_size, bandwidth):
        """make(float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
        return _digital_swig1.fll_band_edge_cc_make(samps_per_sym, rolloff, filter_size, bandwidth)

    make = staticmethod(make)

    def set_samples_per_symbol(self, sps):
        """set_samples_per_symbol(fll_band_edge_cc self, float sps)"""
        return _digital_swig1.fll_band_edge_cc_set_samples_per_symbol(self, sps)


    def set_rolloff(self, rolloff):
        """set_rolloff(fll_band_edge_cc self, float rolloff)"""
        return _digital_swig1.fll_band_edge_cc_set_rolloff(self, rolloff)


    def set_filter_size(self, filter_size):
        """set_filter_size(fll_band_edge_cc self, int filter_size)"""
        return _digital_swig1.fll_band_edge_cc_set_filter_size(self, filter_size)


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


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


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


    def print_taps(self):
        """print_taps(fll_band_edge_cc self)"""
        return _digital_swig1.fll_band_edge_cc_print_taps(self)

    __swig_destroy__ = _digital_swig1.delete_fll_band_edge_cc
    __del__ = lambda self: None
fll_band_edge_cc_swigregister = _digital_swig1.fll_band_edge_cc_swigregister
fll_band_edge_cc_swigregister(fll_band_edge_cc)

def fll_band_edge_cc_make(samps_per_sym, rolloff, filter_size, bandwidth):
    """fll_band_edge_cc_make(float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
    return _digital_swig1.fll_band_edge_cc_make(samps_per_sym, rolloff, filter_size, bandwidth)

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

    thisown = _swig_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

    def make(target_queue):
        """make(msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
        return _digital_swig1.framer_sink_1_make(target_queue)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_framer_sink_1
    __del__ = lambda self: None
framer_sink_1_swigregister = _digital_swig1.framer_sink_1_swigregister
framer_sink_1_swigregister(framer_sink_1)

def framer_sink_1_make(target_queue):
    """framer_sink_1_make(msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
    return _digital_swig1.framer_sink_1_make(target_queue)

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

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

    def __init__(self, mask, seed):
        """__init__(gr::digital::glfsr self, int mask, int seed) -> glfsr"""
        this = _digital_swig1.new_glfsr(mask, seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig1.delete_glfsr
    __del__ = lambda self: None

    def glfsr_mask(degree):
        """glfsr_mask(int degree) -> int"""
        return _digital_swig1.glfsr_glfsr_mask(degree)

    glfsr_mask = staticmethod(glfsr_mask)

    def next_bit(self):
        """next_bit(glfsr self) -> unsigned char"""
        return _digital_swig1.glfsr_next_bit(self)


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

glfsr_swigregister = _digital_swig1.glfsr_swigregister
glfsr_swigregister(glfsr)

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

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

    thisown = _swig_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 make(degree, repeat=True, mask=0, seed=1):
        """make(int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_b_sptr"""
        return _digital_swig1.glfsr_source_b_make(degree, repeat, mask, seed)

    make = staticmethod(make)

    def period(self):
        """period(glfsr_source_b self) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_period(self)


    def mask(self):
        """mask(glfsr_source_b self) -> int"""
        return _digital_swig1.glfsr_source_b_mask(self)

    __swig_destroy__ = _digital_swig1.delete_glfsr_source_b
    __del__ = lambda self: None
glfsr_source_b_swigregister = _digital_swig1.glfsr_source_b_swigregister
glfsr_source_b_swigregister(glfsr_source_b)

def glfsr_source_b_make(degree, repeat=True, mask=0, seed=1):
    """glfsr_source_b_make(int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_b_sptr"""
    return _digital_swig1.glfsr_source_b_make(degree, repeat, mask, seed)

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

    thisown = _swig_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 make(degree, repeat=True, mask=0, seed=1):
        """make(int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_f_sptr"""
        return _digital_swig1.glfsr_source_f_make(degree, repeat, mask, seed)

    make = staticmethod(make)

    def period(self):
        """period(glfsr_source_f self) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_period(self)


    def mask(self):
        """mask(glfsr_source_f self) -> int"""
        return _digital_swig1.glfsr_source_f_mask(self)

    __swig_destroy__ = _digital_swig1.delete_glfsr_source_f
    __del__ = lambda self: None
glfsr_source_f_swigregister = _digital_swig1.glfsr_source_f_swigregister
glfsr_source_f_swigregister(glfsr_source_f)

def glfsr_source_f_make(degree, repeat=True, mask=0, seed=1):
    """glfsr_source_f_make(int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_f_sptr"""
    return _digital_swig1.glfsr_source_f_make(degree, repeat, mask, seed)

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

    thisown = _swig_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

    def make(length_min, length_max):
        """make(int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
        return _digital_swig1.hdlc_deframer_bp_make(length_min, length_max)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_hdlc_deframer_bp
    __del__ = lambda self: None
hdlc_deframer_bp_swigregister = _digital_swig1.hdlc_deframer_bp_swigregister
hdlc_deframer_bp_swigregister(hdlc_deframer_bp)

def hdlc_deframer_bp_make(length_min, length_max):
    """hdlc_deframer_bp_make(int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
    return _digital_swig1.hdlc_deframer_bp_make(length_min, length_max)

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

    thisown = _swig_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

    def make(frame_tag_name):
        """make(std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
        return _digital_swig1.hdlc_framer_pb_make(frame_tag_name)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_hdlc_framer_pb
    __del__ = lambda self: None
hdlc_framer_pb_swigregister = _digital_swig1.hdlc_framer_pb_swigregister
hdlc_framer_pb_swigregister(hdlc_framer_pb)

def hdlc_framer_pb_make(frame_tag_name):
    """hdlc_framer_pb_make(std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
    return _digital_swig1.hdlc_framer_pb_make(frame_tag_name)

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

    thisown = _swig_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

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

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig1.delete_header_payload_demux
    __del__ = lambda self: None
header_payload_demux_swigregister = _digital_swig1.header_payload_demux_swigregister
header_payload_demux_swigregister(header_payload_demux)

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

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

    thisown = _swig_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 make(num_taps, mu):
        """make(int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_make(num_taps, mu)

    make = staticmethod(make)

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


    def set_gain(self, mu):
        """set_gain(kurtotic_equalizer_cc self, float mu)"""
        return _digital_swig1.kurtotic_equalizer_cc_set_gain(self, mu)

    __swig_destroy__ = _digital_swig1.delete_kurtotic_equalizer_cc
    __del__ = lambda self: None
kurtotic_equalizer_cc_swigregister = _digital_swig1.kurtotic_equalizer_cc_swigregister
kurtotic_equalizer_cc_swigregister(kurtotic_equalizer_cc)

def kurtotic_equalizer_cc_make(num_taps, mu):
    """kurtotic_equalizer_cc_make(int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
    return _digital_swig1.kurtotic_equalizer_cc_make(num_taps, mu)

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

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

    def __init__(self, mask, seed, reg_len):
        """__init__(gr::digital::lfsr self, uint32_t mask, uint32_t seed, uint32_t reg_len) -> lfsr"""
        this = _digital_swig1.new_lfsr(mask, seed, reg_len)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


    def reset(self):
        """reset(lfsr self)"""
        return _digital_swig1.lfsr_reset(self)


    def pre_shift(self, num):
        """pre_shift(lfsr self, int num)"""
        return _digital_swig1.lfsr_pre_shift(self, num)


    def mask(self):
        """mask(lfsr self) -> int"""
        return _digital_swig1.lfsr_mask(self)

    __swig_destroy__ = _digital_swig1.delete_lfsr
    __del__ = lambda self: None
lfsr_swigregister = _digital_swig1.lfsr_swigregister
lfsr_swigregister(lfsr)

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

    thisown = _swig_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 make(map):
        """make(std::vector< int,std::allocator< int > > const & map) -> map_bb_sptr"""
        return _digital_swig1.map_bb_make(map)

    make = staticmethod(make)

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


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

    __swig_destroy__ = _digital_swig1.delete_map_bb
    __del__ = lambda self: None
map_bb_swigregister = _digital_swig1.map_bb_swigregister
map_bb_swigregister(map_bb)

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

TRELLIS_EUCLIDEAN = _digital_swig1.TRELLIS_EUCLIDEAN
TRELLIS_HARD_SYMBOL = _digital_swig1.TRELLIS_HARD_SYMBOL
TRELLIS_HARD_BIT = _digital_swig1.TRELLIS_HARD_BIT

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

    thisown = _swig_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 make(sps, gain, limit, osps):
        """make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_make(sps, gain, limit, osps)

    make = staticmethod(make)

    def set_gain(self, gain):
        """set_gain(msk_timing_recovery_cc self, float gain)"""
        return _digital_swig1.msk_timing_recovery_cc_set_gain(self, gain)


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


    def set_limit(self, limit):
        """set_limit(msk_timing_recovery_cc self, float limit)"""
        return _digital_swig1.msk_timing_recovery_cc_set_limit(self, limit)


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


    def set_sps(self, sps):
        """set_sps(msk_timing_recovery_cc self, float sps)"""
        return _digital_swig1.msk_timing_recovery_cc_set_sps(self, sps)


    def get_sps(self):
        """get_sps(msk_timing_recovery_cc self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_get_sps(self)

    __swig_destroy__ = _digital_swig1.delete_msk_timing_recovery_cc
    __del__ = lambda self: None
msk_timing_recovery_cc_swigregister = _digital_swig1.msk_timing_recovery_cc_swigregister
msk_timing_recovery_cc_swigregister(msk_timing_recovery_cc)

def msk_timing_recovery_cc_make(sps, gain, limit, osps):
    """msk_timing_recovery_cc_make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
    return _digital_swig1.msk_timing_recovery_cc_make(sps, gain, limit, osps)

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

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::additive_scrambler_bb)> self) -> additive_scrambler_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::additive_scrambler_bb)> self, additive_scrambler_bb p) -> additive_scrambler_bb_sptr
        """
        this = _digital_swig1.new_additive_scrambler_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(additive_scrambler_bb_sptr self) -> additive_scrambler_bb"""
        return _digital_swig1.additive_scrambler_bb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_additive_scrambler_bb_sptr
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(additive_scrambler_bb_sptr self)"""
        return _digital_swig1.additive_scrambler_bb_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _digital_swig1.additive_scrambler_bb_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(additive_scrambler_bb_sptr self)"""
        return _digital_swig1.additive_scrambler_bb_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(additive_scrambler_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.additive_scrambler_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(additive_scrambler_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(additive_scrambler_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(additive_scrambler_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.additive_scrambler_bb_sptr_message_subscribers(self, which_port)

additive_scrambler_bb_sptr_swigregister = _digital_swig1.additive_scrambler_bb_sptr_swigregister
additive_scrambler_bb_sptr_swigregister(additive_scrambler_bb_sptr)


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

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

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::burst_shaper_cc)> self) -> burst_shaper_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::burst_shaper_cc)> self, burst_shaper_cc p) -> burst_shaper_cc_sptr
        """
        this = _digital_swig1.new_burst_shaper_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(burst_shaper_cc_sptr self) -> burst_shaper_cc"""
        return _digital_swig1.burst_shaper_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_burst_shaper_cc_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(burst_shaper_cc_sptr self, pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name) -> burst_shaper_cc_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_make(self, *args, **kwargs)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(burst_shaper_cc_sptr self, int m)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(burst_shaper_cc_sptr self)"""
        return _digital_swig1.burst_shaper_cc_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(burst_shaper_cc_sptr self, int m)"""
        return _digital_swig1.burst_shaper_cc_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(burst_shaper_cc_sptr self, int which) -> float
        pc_input_buffers_full(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(burst_shaper_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(burst_shaper_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(burst_shaper_cc_sptr self, int which) -> float
        pc_output_buffers_full(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(burst_shaper_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(burst_shaper_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(burst_shaper_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.burst_shaper_cc_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(burst_shaper_cc_sptr self)"""
        return _digital_swig1.burst_shaper_cc_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(burst_shaper_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(burst_shaper_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_cc_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(burst_shaper_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.burst_shaper_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(burst_shaper_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(burst_shaper_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(burst_shaper_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_cc_sptr_message_subscribers(self, which_port)

burst_shaper_cc_sptr_swigregister = _digital_swig1.burst_shaper_cc_sptr_swigregister
burst_shaper_cc_sptr_swigregister(burst_shaper_cc_sptr)


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

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

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::burst_shaper_ff)> self) -> burst_shaper_ff_sptr
        __init__(boost::shared_ptr<(gr::digital::burst_shaper_ff)> self, burst_shaper_ff p) -> burst_shaper_ff_sptr
        """
        this = _digital_swig1.new_burst_shaper_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(burst_shaper_ff_sptr self) -> burst_shaper_ff"""
        return _digital_swig1.burst_shaper_ff_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_burst_shaper_ff_sptr
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(burst_shaper_ff_sptr self, int m)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(burst_shaper_ff_sptr self)"""
        return _digital_swig1.burst_shaper_ff_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(burst_shaper_ff_sptr self, int m)"""
        return _digital_swig1.burst_shaper_ff_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(burst_shaper_ff_sptr self)"""
        return _digital_swig1.burst_shaper_ff_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(burst_shaper_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(burst_shaper_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.burst_shaper_ff_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(burst_shaper_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.burst_shaper_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(burst_shaper_ff_sptr self) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(burst_shaper_ff_sptr self) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(burst_shaper_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.burst_shaper_ff_sptr_message_subscribers(self, which_port)

burst_shaper_ff_sptr_swigregister = _digital_swig1.burst_shaper_ff_sptr_swigregister
burst_shaper_ff_sptr_swigregister(burst_shaper_ff_sptr)


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

class chunks_to_symbols_bc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_bc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_bc)> self) -> chunks_to_symbols_bc_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_bc)> self, chunks_to_symbols_bc p) -> chunks_to_symbols_bc_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_bc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_bc_sptr self) -> chunks_to_symbols_bc"""
        return _digital_swig1.chunks_to_symbols_bc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bc_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_bc_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_bc_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_make(self, symbol_table, D)


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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_bc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_bc_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_symbol_table(self, symbol_table)


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_bc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_bc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_bc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chunks_to_symbols_bc_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_bc_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_bc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(chunks_to_symbols_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_bc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_bc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_bc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_bc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_bc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_bc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bc_sptr_message_subscribers(self, which_port)

chunks_to_symbols_bc_sptr_swigregister = _digital_swig1.chunks_to_symbols_bc_sptr_swigregister
chunks_to_symbols_bc_sptr_swigregister(chunks_to_symbols_bc_sptr)


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

class chunks_to_symbols_bf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_bf)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_bf)> self) -> chunks_to_symbols_bf_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_bf)> self, chunks_to_symbols_bf p) -> chunks_to_symbols_bf_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_bf_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_bf_sptr self) -> chunks_to_symbols_bf"""
        return _digital_swig1.chunks_to_symbols_bf_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_bf_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_bf_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_bf_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_make(self, symbol_table, D)


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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_bf_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_bf_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_symbol_table(self, symbol_table)


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_bf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_bf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_bf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_bf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(chunks_to_symbols_bf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_bf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_bf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_bf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_bf_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_bf_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_bf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_bf_sptr_message_subscribers(self, which_port)

chunks_to_symbols_bf_sptr_swigregister = _digital_swig1.chunks_to_symbols_bf_sptr_swigregister
chunks_to_symbols_bf_sptr_swigregister(chunks_to_symbols_bf_sptr)


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

class chunks_to_symbols_ic_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_ic)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_ic)> self) -> chunks_to_symbols_ic_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_ic)> self, chunks_to_symbols_ic p) -> chunks_to_symbols_ic_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_ic_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_ic_sptr self) -> chunks_to_symbols_ic"""
        return _digital_swig1.chunks_to_symbols_ic_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_ic_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_ic_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_ic_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_make(self, symbol_table, D)


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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_ic_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_ic_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_symbol_table(self, symbol_table)


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_ic_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_ic_sptr self)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_ic_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chunks_to_symbols_ic_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_ic_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_ic_sptr self)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(chunks_to_symbols_ic_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_ic_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_ic_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_ic_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_ic_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_ic_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_ic_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_ic_sptr_message_subscribers(self, which_port)

chunks_to_symbols_ic_sptr_swigregister = _digital_swig1.chunks_to_symbols_ic_sptr_swigregister
chunks_to_symbols_ic_sptr_swigregister(chunks_to_symbols_ic_sptr)


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

class chunks_to_symbols_if_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_if)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_if)> self) -> chunks_to_symbols_if_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_if)> self, chunks_to_symbols_if p) -> chunks_to_symbols_if_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_if_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_if_sptr self) -> chunks_to_symbols_if"""
        return _digital_swig1.chunks_to_symbols_if_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_if_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_if_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_if_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_make(self, symbol_table, D)


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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_if_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_if_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_if_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_symbol_table(self, symbol_table)


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_if_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_if_sptr self)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_if_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chunks_to_symbols_if_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chunks_to_symbols_if_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chunks_to_symbols_if_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chunks_to_symbols_if_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chunks_to_symbols_if_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chunks_to_symbols_if_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_if_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_if_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_if_sptr self)"""
        return _digital_swig1.chunks_to_symbols_if_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(chunks_to_symbols_if_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_if_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_if_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_if_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_if_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_if_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_if_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_if_sptr_message_subscribers(self, which_port)

chunks_to_symbols_if_sptr_swigregister = _digital_swig1.chunks_to_symbols_if_sptr_swigregister
chunks_to_symbols_if_sptr_swigregister(chunks_to_symbols_if_sptr)


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

class chunks_to_symbols_sc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_sc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_sc)> self) -> chunks_to_symbols_sc_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_sc)> self, chunks_to_symbols_sc p) -> chunks_to_symbols_sc_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_sc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_sc_sptr self) -> chunks_to_symbols_sc"""
        return _digital_swig1.chunks_to_symbols_sc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sc_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_sc_sptr self, pmt_vector_cfloat symbol_table, int const D=1) -> chunks_to_symbols_sc_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_make(self, symbol_table, D)


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


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_sc_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_sc_sptr self, pmt_vector_cfloat symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_symbol_table(self, symbol_table)


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


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


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


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


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


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


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


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


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


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_sc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_sc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_unset_max_noutput_items(self)


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


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_sc_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_set_min_noutput_items(self, m)


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


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


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


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


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


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


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


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


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


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


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


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chunks_to_symbols_sc_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sc_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_sc_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_unset_processor_affinity(self)


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


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


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


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


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


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


    def input_signature(self):
        """input_signature(chunks_to_symbols_sc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_sc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_output_signature(self)


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


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


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


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


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


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_sc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_sc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_sc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_sc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_sc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sc_sptr_message_subscribers(self, which_port)

chunks_to_symbols_sc_sptr_swigregister = _digital_swig1.chunks_to_symbols_sc_sptr_swigregister
chunks_to_symbols_sc_sptr_swigregister(chunks_to_symbols_sc_sptr)


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

class chunks_to_symbols_sf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::chunks_to_symbols_sf)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_sf)> self) -> chunks_to_symbols_sf_sptr
        __init__(boost::shared_ptr<(gr::digital::chunks_to_symbols_sf)> self, chunks_to_symbols_sf p) -> chunks_to_symbols_sf_sptr
        """
        this = _digital_swig1.new_chunks_to_symbols_sf_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chunks_to_symbols_sf_sptr self) -> chunks_to_symbols_sf"""
        return _digital_swig1.chunks_to_symbols_sf_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_chunks_to_symbols_sf_sptr
    __del__ = lambda self: None

    def make(self, symbol_table, D=1):
        """make(chunks_to_symbols_sf_sptr self, pmt_vector_float symbol_table, int const D=1) -> chunks_to_symbols_sf_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_make(self, symbol_table, D)


    def D(self):
        """D(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_D(self)


    def symbol_table(self):
        """symbol_table(chunks_to_symbols_sf_sptr self) -> pmt_vector_float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_symbol_table(self)


    def set_symbol_table(self, symbol_table):
        """set_symbol_table(chunks_to_symbols_sf_sptr self, pmt_vector_float symbol_table)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_symbol_table(self, symbol_table)


    def history(self):
        """history(chunks_to_symbols_sf_sptr self) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(chunks_to_symbols_sf_sptr self, int which, int delay)
        declare_sample_delay(chunks_to_symbols_sf_sptr self, unsigned int delay)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(chunks_to_symbols_sf_sptr self, int which) -> unsigned int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(chunks_to_symbols_sf_sptr self) -> double"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_relative_rate(self)


    def start(self):
        """start(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_start(self)


    def stop(self):
        """stop(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(chunks_to_symbols_sf_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(chunks_to_symbols_sf_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chunks_to_symbols_sf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chunks_to_symbols_sf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(chunks_to_symbols_sf_sptr self) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chunks_to_symbols_sf_sptr self, int m)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(chunks_to_symbols_sf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(chunks_to_symbols_sf_sptr self, long max_output_buffer)
        set_max_output_buffer(chunks_to_symbols_sf_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(chunks_to_symbols_sf_sptr self, int i) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(chunks_to_symbols_sf_sptr self, long min_output_buffer)
        set_min_output_buffer(chunks_to_symbols_sf_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_input_buffers_full(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_input_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_input_buffers_full_var(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_output_buffers_full(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_output_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chunks_to_symbols_sf_sptr self, int which) -> float
        pc_output_buffers_full_var(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(chunks_to_symbols_sf_sptr self) -> float"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(chunks_to_symbols_sf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(chunks_to_symbols_sf_sptr self)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(chunks_to_symbols_sf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(chunks_to_symbols_sf_sptr self) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(chunks_to_symbols_sf_sptr self, int priority) -> int"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(chunks_to_symbols_sf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chunks_to_symbols_sf_sptr self) -> io_signature_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(chunks_to_symbols_sf_sptr self) -> long"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(chunks_to_symbols_sf_sptr self) -> basic_block_sptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(chunks_to_symbols_sf_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(chunks_to_symbols_sf_sptr self) -> std::string"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(chunks_to_symbols_sf_sptr self, std::string name)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(chunks_to_symbols_sf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.chunks_to_symbols_sf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chunks_to_symbols_sf_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chunks_to_symbols_sf_sptr self) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chunks_to_symbols_sf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.chunks_to_symbols_sf_sptr_message_subscribers(self, which_port)

chunks_to_symbols_sf_sptr_swigregister = _digital_swig1.chunks_to_symbols_sf_sptr_swigregister
chunks_to_symbols_sf_sptr_swigregister(chunks_to_symbols_sf_sptr)


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

class clock_recovery_mm_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::clock_recovery_mm_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::clock_recovery_mm_cc)> self) -> clock_recovery_mm_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::clock_recovery_mm_cc)> self, clock_recovery_mm_cc p) -> clock_recovery_mm_cc_sptr
        """
        this = _digital_swig1.new_clock_recovery_mm_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(clock_recovery_mm_cc_sptr self) -> clock_recovery_mm_cc"""
        return _digital_swig1.clock_recovery_mm_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_cc_sptr
    __del__ = lambda self: None

    def make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit):
        """make(clock_recovery_mm_cc_sptr self, float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_cc_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit)


    def mu(self):
        """mu(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_mu(self)


    def omega(self):
        """omega(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_omega(self)


    def gain_mu(self):
        """gain_mu(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_gain_mu(self)


    def gain_omega(self):
        """gain_omega(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_gain_omega(self)


    def set_verbose(self, verbose):
        """set_verbose(clock_recovery_mm_cc_sptr self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_verbose(self, verbose)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(clock_recovery_mm_cc_sptr self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(clock_recovery_mm_cc_sptr self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_gain_omega(self, gain_omega)


    def set_mu(self, mu):
        """set_mu(clock_recovery_mm_cc_sptr self, float mu)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(clock_recovery_mm_cc_sptr self, float omega)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_omega(self, omega)


    def history(self):
        """history(clock_recovery_mm_cc_sptr self) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(clock_recovery_mm_cc_sptr self, int which, int delay)
        declare_sample_delay(clock_recovery_mm_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(clock_recovery_mm_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(clock_recovery_mm_cc_sptr self) -> double"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_relative_rate(self)


    def start(self):
        """start(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_start(self)


    def stop(self):
        """stop(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(clock_recovery_mm_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(clock_recovery_mm_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(clock_recovery_mm_cc_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(clock_recovery_mm_cc_sptr self)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(clock_recovery_mm_cc_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(clock_recovery_mm_cc_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(clock_recovery_mm_cc_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(clock_recovery_mm_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(clock_recovery_mm_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(clock_recovery_mm_cc_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(clock_recovery_mm_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(clock_recovery_mm_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_input_buffers_full(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_output_buffers_full(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(clock_recovery_mm_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(clock_recovery_mm_cc_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(clock_recovery_mm_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(clock_recovery_mm_cc_sptr self)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(clock_recovery_mm_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(clock_recovery_mm_cc_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(clock_recovery_mm_cc_sptr self, int priority) -> int"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(clock_recovery_mm_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(clock_recovery_mm_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(clock_recovery_mm_cc_sptr self) -> long"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(clock_recovery_mm_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(clock_recovery_mm_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(clock_recovery_mm_cc_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(clock_recovery_mm_cc_sptr self, std::string name)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(clock_recovery_mm_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.clock_recovery_mm_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(clock_recovery_mm_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(clock_recovery_mm_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(clock_recovery_mm_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_cc_sptr_message_subscribers(self, which_port)

clock_recovery_mm_cc_sptr_swigregister = _digital_swig1.clock_recovery_mm_cc_sptr_swigregister
clock_recovery_mm_cc_sptr_swigregister(clock_recovery_mm_cc_sptr)


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

class clock_recovery_mm_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::clock_recovery_mm_ff)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::clock_recovery_mm_ff)> self) -> clock_recovery_mm_ff_sptr
        __init__(boost::shared_ptr<(gr::digital::clock_recovery_mm_ff)> self, clock_recovery_mm_ff p) -> clock_recovery_mm_ff_sptr
        """
        this = _digital_swig1.new_clock_recovery_mm_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(clock_recovery_mm_ff_sptr self) -> clock_recovery_mm_ff"""
        return _digital_swig1.clock_recovery_mm_ff_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_clock_recovery_mm_ff_sptr
    __del__ = lambda self: None

    def make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit):
        """make(clock_recovery_mm_ff_sptr self, float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) -> clock_recovery_mm_ff_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_make(self, omega, gain_omega, mu, gain_mu, omega_relative_limit)


    def mu(self):
        """mu(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_mu(self)


    def omega(self):
        """omega(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_omega(self)


    def gain_mu(self):
        """gain_mu(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_gain_mu(self)


    def gain_omega(self):
        """gain_omega(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_gain_omega(self)


    def set_verbose(self, verbose):
        """set_verbose(clock_recovery_mm_ff_sptr self, bool verbose)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_verbose(self, verbose)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(clock_recovery_mm_ff_sptr self, float gain_mu)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(clock_recovery_mm_ff_sptr self, float gain_omega)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_gain_omega(self, gain_omega)


    def set_mu(self, mu):
        """set_mu(clock_recovery_mm_ff_sptr self, float mu)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(clock_recovery_mm_ff_sptr self, float omega)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_omega(self, omega)


    def history(self):
        """history(clock_recovery_mm_ff_sptr self) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(clock_recovery_mm_ff_sptr self, int which, int delay)
        declare_sample_delay(clock_recovery_mm_ff_sptr self, unsigned int delay)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(clock_recovery_mm_ff_sptr self, int which) -> unsigned int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(clock_recovery_mm_ff_sptr self) -> double"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_relative_rate(self)


    def start(self):
        """start(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_start(self)


    def stop(self):
        """stop(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(clock_recovery_mm_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(clock_recovery_mm_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(clock_recovery_mm_ff_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(clock_recovery_mm_ff_sptr self)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(clock_recovery_mm_ff_sptr self) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(clock_recovery_mm_ff_sptr self, int m)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(clock_recovery_mm_ff_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(clock_recovery_mm_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(clock_recovery_mm_ff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(clock_recovery_mm_ff_sptr self, int i) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(clock_recovery_mm_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(clock_recovery_mm_ff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(clock_recovery_mm_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(clock_recovery_mm_ff_sptr self) -> float"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(clock_recovery_mm_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(clock_recovery_mm_ff_sptr self)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(clock_recovery_mm_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(clock_recovery_mm_ff_sptr self) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(clock_recovery_mm_ff_sptr self, int priority) -> int"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(clock_recovery_mm_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(clock_recovery_mm_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(clock_recovery_mm_ff_sptr self) -> long"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(clock_recovery_mm_ff_sptr self) -> basic_block_sptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(clock_recovery_mm_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(clock_recovery_mm_ff_sptr self) -> std::string"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(clock_recovery_mm_ff_sptr self, std::string name)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(clock_recovery_mm_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.clock_recovery_mm_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(clock_recovery_mm_ff_sptr self) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(clock_recovery_mm_ff_sptr self) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(clock_recovery_mm_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.clock_recovery_mm_ff_sptr_message_subscribers(self, which_port)

clock_recovery_mm_ff_sptr_swigregister = _digital_swig1.clock_recovery_mm_ff_sptr_swigregister
clock_recovery_mm_ff_sptr_swigregister(clock_recovery_mm_ff_sptr)


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

class diff_decoder_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::diff_decoder_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::diff_decoder_bb)> self) -> diff_decoder_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::diff_decoder_bb)> self, diff_decoder_bb p) -> diff_decoder_bb_sptr
        """
        this = _digital_swig1.new_diff_decoder_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(diff_decoder_bb_sptr self) -> diff_decoder_bb"""
        return _digital_swig1.diff_decoder_bb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_diff_decoder_bb_sptr
    __del__ = lambda self: None

    def make(self, modulus):
        """make(diff_decoder_bb_sptr self, unsigned int modulus) -> diff_decoder_bb_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_make(self, modulus)


    def history(self):
        """history(diff_decoder_bb_sptr self) -> unsigned int"""
        return _digital_swig1.diff_decoder_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(diff_decoder_bb_sptr self, int which, int delay)
        declare_sample_delay(diff_decoder_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_decoder_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(diff_decoder_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_decoder_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(diff_decoder_bb_sptr self) -> double"""
        return _digital_swig1.diff_decoder_bb_sptr_relative_rate(self)


    def start(self):
        """start(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_start(self)


    def stop(self):
        """stop(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(diff_decoder_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(diff_decoder_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_decoder_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(diff_decoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(diff_decoder_bb_sptr self)"""
        return _digital_swig1.diff_decoder_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(diff_decoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(diff_decoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(diff_decoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(diff_decoder_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_decoder_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_decoder_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(diff_decoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(diff_decoder_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_decoder_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_decoder_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(diff_decoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(diff_decoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(diff_decoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_decoder_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(diff_decoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_decoder_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(diff_decoder_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(diff_decoder_bb_sptr self)"""
        return _digital_swig1.diff_decoder_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(diff_decoder_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_decoder_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(diff_decoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(diff_decoder_bb_sptr self, int priority) -> int"""
        return _digital_swig1.diff_decoder_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(diff_decoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(diff_decoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(diff_decoder_bb_sptr self) -> long"""
        return _digital_swig1.diff_decoder_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(diff_decoder_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_decoder_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(diff_decoder_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_decoder_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(diff_decoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_decoder_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(diff_decoder_bb_sptr self, std::string name)"""
        return _digital_swig1.diff_decoder_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(diff_decoder_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.diff_decoder_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(diff_decoder_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(diff_decoder_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(diff_decoder_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.diff_decoder_bb_sptr_message_subscribers(self, which_port)

diff_decoder_bb_sptr_swigregister = _digital_swig1.diff_decoder_bb_sptr_swigregister
diff_decoder_bb_sptr_swigregister(diff_decoder_bb_sptr)


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

class diff_encoder_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::diff_encoder_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::diff_encoder_bb)> self) -> diff_encoder_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::diff_encoder_bb)> self, diff_encoder_bb p) -> diff_encoder_bb_sptr
        """
        this = _digital_swig1.new_diff_encoder_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(diff_encoder_bb_sptr self) -> diff_encoder_bb"""
        return _digital_swig1.diff_encoder_bb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_diff_encoder_bb_sptr
    __del__ = lambda self: None

    def make(self, modulus):
        """make(diff_encoder_bb_sptr self, unsigned int modulus) -> diff_encoder_bb_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_make(self, modulus)


    def history(self):
        """history(diff_encoder_bb_sptr self) -> unsigned int"""
        return _digital_swig1.diff_encoder_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(diff_encoder_bb_sptr self, int which, int delay)
        declare_sample_delay(diff_encoder_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_encoder_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(diff_encoder_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_encoder_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(diff_encoder_bb_sptr self) -> double"""
        return _digital_swig1.diff_encoder_bb_sptr_relative_rate(self)


    def start(self):
        """start(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_start(self)


    def stop(self):
        """stop(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(diff_encoder_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(diff_encoder_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_encoder_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(diff_encoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(diff_encoder_bb_sptr self)"""
        return _digital_swig1.diff_encoder_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(diff_encoder_bb_sptr self) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(diff_encoder_bb_sptr self, int m)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(diff_encoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(diff_encoder_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_encoder_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_encoder_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(diff_encoder_bb_sptr self, int i) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(diff_encoder_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_encoder_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_encoder_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(diff_encoder_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(diff_encoder_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(diff_encoder_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_encoder_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(diff_encoder_bb_sptr self) -> float"""
        return _digital_swig1.diff_encoder_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(diff_encoder_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(diff_encoder_bb_sptr self)"""
        return _digital_swig1.diff_encoder_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(diff_encoder_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_encoder_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(diff_encoder_bb_sptr self) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(diff_encoder_bb_sptr self, int priority) -> int"""
        return _digital_swig1.diff_encoder_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(diff_encoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(diff_encoder_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(diff_encoder_bb_sptr self) -> long"""
        return _digital_swig1.diff_encoder_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(diff_encoder_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_encoder_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(diff_encoder_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_encoder_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(diff_encoder_bb_sptr self) -> std::string"""
        return _digital_swig1.diff_encoder_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(diff_encoder_bb_sptr self, std::string name)"""
        return _digital_swig1.diff_encoder_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(diff_encoder_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.diff_encoder_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(diff_encoder_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(diff_encoder_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(diff_encoder_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.diff_encoder_bb_sptr_message_subscribers(self, which_port)

diff_encoder_bb_sptr_swigregister = _digital_swig1.diff_encoder_bb_sptr_swigregister
diff_encoder_bb_sptr_swigregister(diff_encoder_bb_sptr)


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

class diff_phasor_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::diff_phasor_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::diff_phasor_cc)> self) -> diff_phasor_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::diff_phasor_cc)> self, diff_phasor_cc p) -> diff_phasor_cc_sptr
        """
        this = _digital_swig1.new_diff_phasor_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(diff_phasor_cc_sptr self) -> diff_phasor_cc"""
        return _digital_swig1.diff_phasor_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_diff_phasor_cc_sptr
    __del__ = lambda self: None

    def make(self):
        """make(diff_phasor_cc_sptr self) -> diff_phasor_cc_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_make(self)


    def history(self):
        """history(diff_phasor_cc_sptr self) -> unsigned int"""
        return _digital_swig1.diff_phasor_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(diff_phasor_cc_sptr self, int which, int delay)
        declare_sample_delay(diff_phasor_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.diff_phasor_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(diff_phasor_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.diff_phasor_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(diff_phasor_cc_sptr self) -> double"""
        return _digital_swig1.diff_phasor_cc_sptr_relative_rate(self)


    def start(self):
        """start(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_start(self)


    def stop(self):
        """stop(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(diff_phasor_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(diff_phasor_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.diff_phasor_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(diff_phasor_cc_sptr self, int m)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(diff_phasor_cc_sptr self)"""
        return _digital_swig1.diff_phasor_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(diff_phasor_cc_sptr self) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(diff_phasor_cc_sptr self, int m)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(diff_phasor_cc_sptr self, int i) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(diff_phasor_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(diff_phasor_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.diff_phasor_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(diff_phasor_cc_sptr self, int i) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(diff_phasor_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(diff_phasor_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.diff_phasor_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(diff_phasor_cc_sptr self, int which) -> float
        pc_input_buffers_full(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(diff_phasor_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(diff_phasor_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(diff_phasor_cc_sptr self, int which) -> float
        pc_output_buffers_full(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(diff_phasor_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(diff_phasor_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(diff_phasor_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.diff_phasor_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(diff_phasor_cc_sptr self) -> float"""
        return _digital_swig1.diff_phasor_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(diff_phasor_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(diff_phasor_cc_sptr self)"""
        return _digital_swig1.diff_phasor_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(diff_phasor_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.diff_phasor_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(diff_phasor_cc_sptr self) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(diff_phasor_cc_sptr self, int priority) -> int"""
        return _digital_swig1.diff_phasor_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(diff_phasor_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(diff_phasor_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(diff_phasor_cc_sptr self) -> long"""
        return _digital_swig1.diff_phasor_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(diff_phasor_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.diff_phasor_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(diff_phasor_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.diff_phasor_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(diff_phasor_cc_sptr self) -> std::string"""
        return _digital_swig1.diff_phasor_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(diff_phasor_cc_sptr self, std::string name)"""
        return _digital_swig1.diff_phasor_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(diff_phasor_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.diff_phasor_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(diff_phasor_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(diff_phasor_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(diff_phasor_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.diff_phasor_cc_sptr_message_subscribers(self, which_port)

diff_phasor_cc_sptr_swigregister = _digital_swig1.diff_phasor_cc_sptr_swigregister
diff_phasor_cc_sptr_swigregister(diff_phasor_cc_sptr)


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

class fll_band_edge_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::fll_band_edge_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::fll_band_edge_cc)> self) -> fll_band_edge_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::fll_band_edge_cc)> self, fll_band_edge_cc p) -> fll_band_edge_cc_sptr
        """
        this = _digital_swig1.new_fll_band_edge_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(fll_band_edge_cc_sptr self) -> fll_band_edge_cc"""
        return _digital_swig1.fll_band_edge_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_fll_band_edge_cc_sptr
    __del__ = lambda self: None

    def make(self, samps_per_sym, rolloff, filter_size, bandwidth):
        """make(fll_band_edge_cc_sptr self, float samps_per_sym, float rolloff, int filter_size, float bandwidth) -> fll_band_edge_cc_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_make(self, samps_per_sym, rolloff, filter_size, bandwidth)


    def set_samples_per_symbol(self, sps):
        """set_samples_per_symbol(fll_band_edge_cc_sptr self, float sps)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_samples_per_symbol(self, sps)


    def set_rolloff(self, rolloff):
        """set_rolloff(fll_band_edge_cc_sptr self, float rolloff)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_rolloff(self, rolloff)


    def set_filter_size(self, filter_size):
        """set_filter_size(fll_band_edge_cc_sptr self, int filter_size)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_filter_size(self, filter_size)


    def samples_per_symbol(self):
        """samples_per_symbol(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_samples_per_symbol(self)


    def rolloff(self):
        """rolloff(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_rolloff(self)


    def filter_size(self):
        """filter_size(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_filter_size(self)


    def print_taps(self):
        """print_taps(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_print_taps(self)


    def history(self):
        """history(fll_band_edge_cc_sptr self) -> unsigned int"""
        return _digital_swig1.fll_band_edge_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(fll_band_edge_cc_sptr self, int which, int delay)
        declare_sample_delay(fll_band_edge_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(fll_band_edge_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.fll_band_edge_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fll_band_edge_cc_sptr self) -> double"""
        return _digital_swig1.fll_band_edge_cc_sptr_relative_rate(self)


    def start(self):
        """start(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_start(self)


    def stop(self):
        """stop(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(fll_band_edge_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(fll_band_edge_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.fll_band_edge_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(fll_band_edge_cc_sptr self, int m)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(fll_band_edge_cc_sptr self) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(fll_band_edge_cc_sptr self, int m)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(fll_band_edge_cc_sptr self, int i) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(fll_band_edge_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(fll_band_edge_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(fll_band_edge_cc_sptr self, int i) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(fll_band_edge_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(fll_band_edge_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(fll_band_edge_cc_sptr self, int which) -> float
        pc_input_buffers_full(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(fll_band_edge_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(fll_band_edge_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(fll_band_edge_cc_sptr self, int which) -> float
        pc_output_buffers_full(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(fll_band_edge_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(fll_band_edge_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(fll_band_edge_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.fll_band_edge_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(fll_band_edge_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(fll_band_edge_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.fll_band_edge_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fll_band_edge_cc_sptr self) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(fll_band_edge_cc_sptr self, int priority) -> int"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fll_band_edge_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fll_band_edge_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fll_band_edge_cc_sptr self) -> long"""
        return _digital_swig1.fll_band_edge_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(fll_band_edge_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(fll_band_edge_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.fll_band_edge_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(fll_band_edge_cc_sptr self) -> std::string"""
        return _digital_swig1.fll_band_edge_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(fll_band_edge_cc_sptr self, std::string name)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(fll_band_edge_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.fll_band_edge_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fll_band_edge_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fll_band_edge_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fll_band_edge_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.fll_band_edge_cc_sptr_message_subscribers(self, which_port)


    def update_gains(self):
        """update_gains(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(fll_band_edge_cc_sptr self, float error)"""
        return _digital_swig1.fll_band_edge_cc_sptr_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(fll_band_edge_cc_sptr self)"""
        return _digital_swig1.fll_band_edge_cc_sptr_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(fll_band_edge_cc_sptr self, float bw)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_loop_bandwidth(self, bw)


    def set_damping_factor(self, df):
        """set_damping_factor(fll_band_edge_cc_sptr self, float df)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_damping_factor(self, df)


    def set_alpha(self, alpha):
        """set_alpha(fll_band_edge_cc_sptr self, float alpha)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(fll_band_edge_cc_sptr self, float beta)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(fll_band_edge_cc_sptr self, float phase)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_phase(self, phase)


    def set_max_freq(self, freq):
        """set_max_freq(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_max_freq(self, freq)


    def set_min_freq(self, freq):
        """set_min_freq(fll_band_edge_cc_sptr self, float freq)"""
        return _digital_swig1.fll_band_edge_cc_sptr_set_min_freq(self, freq)


    def get_loop_bandwidth(self):
        """get_loop_bandwidth(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_loop_bandwidth(self)


    def get_damping_factor(self):
        """get_damping_factor(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_alpha(self)


    def get_beta(self):
        """get_beta(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_beta(self)


    def get_frequency(self):
        """get_frequency(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_frequency(self)


    def get_phase(self):
        """get_phase(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_phase(self)


    def get_max_freq(self):
        """get_max_freq(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_max_freq(self)


    def get_min_freq(self):
        """get_min_freq(fll_band_edge_cc_sptr self) -> float"""
        return _digital_swig1.fll_band_edge_cc_sptr_get_min_freq(self)

fll_band_edge_cc_sptr_swigregister = _digital_swig1.fll_band_edge_cc_sptr_swigregister
fll_band_edge_cc_sptr_swigregister(fll_band_edge_cc_sptr)


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

class framer_sink_1_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::framer_sink_1)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::framer_sink_1)> self) -> framer_sink_1_sptr
        __init__(boost::shared_ptr<(gr::digital::framer_sink_1)> self, framer_sink_1 p) -> framer_sink_1_sptr
        """
        this = _digital_swig1.new_framer_sink_1_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(framer_sink_1_sptr self) -> framer_sink_1"""
        return _digital_swig1.framer_sink_1_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_framer_sink_1_sptr
    __del__ = lambda self: None

    def make(self, target_queue):
        """make(framer_sink_1_sptr self, msg_queue_sptr target_queue) -> framer_sink_1_sptr"""
        return _digital_swig1.framer_sink_1_sptr_make(self, target_queue)


    def history(self):
        """history(framer_sink_1_sptr self) -> unsigned int"""
        return _digital_swig1.framer_sink_1_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(framer_sink_1_sptr self, int which, int delay)
        declare_sample_delay(framer_sink_1_sptr self, unsigned int delay)
        """
        return _digital_swig1.framer_sink_1_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(framer_sink_1_sptr self, int which) -> unsigned int"""
        return _digital_swig1.framer_sink_1_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(framer_sink_1_sptr self) -> double"""
        return _digital_swig1.framer_sink_1_sptr_relative_rate(self)


    def start(self):
        """start(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_start(self)


    def stop(self):
        """stop(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(framer_sink_1_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(framer_sink_1_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.framer_sink_1_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(framer_sink_1_sptr self, int m)"""
        return _digital_swig1.framer_sink_1_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(framer_sink_1_sptr self)"""
        return _digital_swig1.framer_sink_1_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(framer_sink_1_sptr self) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(framer_sink_1_sptr self, int m)"""
        return _digital_swig1.framer_sink_1_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(framer_sink_1_sptr self, int i) -> long"""
        return _digital_swig1.framer_sink_1_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(framer_sink_1_sptr self, long max_output_buffer)
        set_max_output_buffer(framer_sink_1_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.framer_sink_1_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(framer_sink_1_sptr self, int i) -> long"""
        return _digital_swig1.framer_sink_1_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(framer_sink_1_sptr self, long min_output_buffer)
        set_min_output_buffer(framer_sink_1_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.framer_sink_1_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(framer_sink_1_sptr self, int which) -> float
        pc_input_buffers_full(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(framer_sink_1_sptr self, int which) -> float
        pc_input_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(framer_sink_1_sptr self, int which) -> float
        pc_input_buffers_full_var(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(framer_sink_1_sptr self, int which) -> float
        pc_output_buffers_full(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(framer_sink_1_sptr self, int which) -> float
        pc_output_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(framer_sink_1_sptr self, int which) -> float
        pc_output_buffers_full_var(framer_sink_1_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.framer_sink_1_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(framer_sink_1_sptr self) -> float"""
        return _digital_swig1.framer_sink_1_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(framer_sink_1_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.framer_sink_1_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(framer_sink_1_sptr self)"""
        return _digital_swig1.framer_sink_1_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(framer_sink_1_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.framer_sink_1_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(framer_sink_1_sptr self) -> int"""
        return _digital_swig1.framer_sink_1_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(framer_sink_1_sptr self, int priority) -> int"""
        return _digital_swig1.framer_sink_1_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_name(self)


    def symbol_name(self):
        """symbol_name(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(framer_sink_1_sptr self) -> io_signature_sptr"""
        return _digital_swig1.framer_sink_1_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(framer_sink_1_sptr self) -> io_signature_sptr"""
        return _digital_swig1.framer_sink_1_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(framer_sink_1_sptr self) -> long"""
        return _digital_swig1.framer_sink_1_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(framer_sink_1_sptr self) -> basic_block_sptr"""
        return _digital_swig1.framer_sink_1_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(framer_sink_1_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.framer_sink_1_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(framer_sink_1_sptr self) -> std::string"""
        return _digital_swig1.framer_sink_1_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(framer_sink_1_sptr self, std::string name)"""
        return _digital_swig1.framer_sink_1_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(framer_sink_1_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.framer_sink_1_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(framer_sink_1_sptr self) -> swig_int_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(framer_sink_1_sptr self) -> swig_int_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(framer_sink_1_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.framer_sink_1_sptr_message_subscribers(self, which_port)

framer_sink_1_sptr_swigregister = _digital_swig1.framer_sink_1_sptr_swigregister
framer_sink_1_sptr_swigregister(framer_sink_1_sptr)


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

class glfsr_source_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::glfsr_source_b)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::glfsr_source_b)> self) -> glfsr_source_b_sptr
        __init__(boost::shared_ptr<(gr::digital::glfsr_source_b)> self, glfsr_source_b p) -> glfsr_source_b_sptr
        """
        this = _digital_swig1.new_glfsr_source_b_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(glfsr_source_b_sptr self) -> glfsr_source_b"""
        return _digital_swig1.glfsr_source_b_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_glfsr_source_b_sptr
    __del__ = lambda self: None

    def make(self, degree, repeat=True, mask=0, seed=1):
        """make(glfsr_source_b_sptr self, int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_b_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_make(self, degree, repeat, mask, seed)


    def period(self):
        """period(glfsr_source_b_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_sptr_period(self)


    def mask(self):
        """mask(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_mask(self)


    def history(self):
        """history(glfsr_source_b_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(glfsr_source_b_sptr self, int which, int delay)
        declare_sample_delay(glfsr_source_b_sptr self, unsigned int delay)
        """
        return _digital_swig1.glfsr_source_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(glfsr_source_b_sptr self, int which) -> unsigned int"""
        return _digital_swig1.glfsr_source_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(glfsr_source_b_sptr self) -> double"""
        return _digital_swig1.glfsr_source_b_sptr_relative_rate(self)


    def start(self):
        """start(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_start(self)


    def stop(self):
        """stop(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(glfsr_source_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(glfsr_source_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.glfsr_source_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(glfsr_source_b_sptr self, int m)"""
        return _digital_swig1.glfsr_source_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(glfsr_source_b_sptr self)"""
        return _digital_swig1.glfsr_source_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(glfsr_source_b_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(glfsr_source_b_sptr self, int m)"""
        return _digital_swig1.glfsr_source_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(glfsr_source_b_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(glfsr_source_b_sptr self, long max_output_buffer)
        set_max_output_buffer(glfsr_source_b_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.glfsr_source_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(glfsr_source_b_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(glfsr_source_b_sptr self, long min_output_buffer)
        set_min_output_buffer(glfsr_source_b_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.glfsr_source_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(glfsr_source_b_sptr self, int which) -> float
        pc_input_buffers_full(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(glfsr_source_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(glfsr_source_b_sptr self, int which) -> float
        pc_input_buffers_full_var(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(glfsr_source_b_sptr self, int which) -> float
        pc_output_buffers_full(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(glfsr_source_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(glfsr_source_b_sptr self, int which) -> float
        pc_output_buffers_full_var(glfsr_source_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(glfsr_source_b_sptr self) -> float"""
        return _digital_swig1.glfsr_source_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(glfsr_source_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.glfsr_source_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(glfsr_source_b_sptr self)"""
        return _digital_swig1.glfsr_source_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(glfsr_source_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.glfsr_source_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(glfsr_source_b_sptr self) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(glfsr_source_b_sptr self, int priority) -> int"""
        return _digital_swig1.glfsr_source_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(glfsr_source_b_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(glfsr_source_b_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(glfsr_source_b_sptr self) -> long"""
        return _digital_swig1.glfsr_source_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(glfsr_source_b_sptr self) -> basic_block_sptr"""
        return _digital_swig1.glfsr_source_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(glfsr_source_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.glfsr_source_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(glfsr_source_b_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(glfsr_source_b_sptr self, std::string name)"""
        return _digital_swig1.glfsr_source_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(glfsr_source_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.glfsr_source_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(glfsr_source_b_sptr self) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(glfsr_source_b_sptr self) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(glfsr_source_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_b_sptr_message_subscribers(self, which_port)

glfsr_source_b_sptr_swigregister = _digital_swig1.glfsr_source_b_sptr_swigregister
glfsr_source_b_sptr_swigregister(glfsr_source_b_sptr)


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

class glfsr_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::glfsr_source_f)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::glfsr_source_f)> self) -> glfsr_source_f_sptr
        __init__(boost::shared_ptr<(gr::digital::glfsr_source_f)> self, glfsr_source_f p) -> glfsr_source_f_sptr
        """
        this = _digital_swig1.new_glfsr_source_f_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(glfsr_source_f_sptr self) -> glfsr_source_f"""
        return _digital_swig1.glfsr_source_f_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_glfsr_source_f_sptr
    __del__ = lambda self: None

    def make(self, degree, repeat=True, mask=0, seed=1):
        """make(glfsr_source_f_sptr self, int degree, bool repeat=True, int mask=0, int seed=1) -> glfsr_source_f_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_make(self, degree, repeat, mask, seed)


    def period(self):
        """period(glfsr_source_f_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_sptr_period(self)


    def mask(self):
        """mask(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_mask(self)


    def history(self):
        """history(glfsr_source_f_sptr self) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(glfsr_source_f_sptr self, int which, int delay)
        declare_sample_delay(glfsr_source_f_sptr self, unsigned int delay)
        """
        return _digital_swig1.glfsr_source_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(glfsr_source_f_sptr self, int which) -> unsigned int"""
        return _digital_swig1.glfsr_source_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(glfsr_source_f_sptr self) -> double"""
        return _digital_swig1.glfsr_source_f_sptr_relative_rate(self)


    def start(self):
        """start(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_start(self)


    def stop(self):
        """stop(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(glfsr_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(glfsr_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.glfsr_source_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(glfsr_source_f_sptr self, int m)"""
        return _digital_swig1.glfsr_source_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(glfsr_source_f_sptr self)"""
        return _digital_swig1.glfsr_source_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(glfsr_source_f_sptr self) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(glfsr_source_f_sptr self, int m)"""
        return _digital_swig1.glfsr_source_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(glfsr_source_f_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(glfsr_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(glfsr_source_f_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.glfsr_source_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(glfsr_source_f_sptr self, int i) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(glfsr_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(glfsr_source_f_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.glfsr_source_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(glfsr_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(glfsr_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(glfsr_source_f_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.glfsr_source_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(glfsr_source_f_sptr self) -> float"""
        return _digital_swig1.glfsr_source_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(glfsr_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.glfsr_source_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(glfsr_source_f_sptr self)"""
        return _digital_swig1.glfsr_source_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(glfsr_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.glfsr_source_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(glfsr_source_f_sptr self) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(glfsr_source_f_sptr self, int priority) -> int"""
        return _digital_swig1.glfsr_source_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(glfsr_source_f_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(glfsr_source_f_sptr self) -> io_signature_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(glfsr_source_f_sptr self) -> long"""
        return _digital_swig1.glfsr_source_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(glfsr_source_f_sptr self) -> basic_block_sptr"""
        return _digital_swig1.glfsr_source_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(glfsr_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.glfsr_source_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(glfsr_source_f_sptr self) -> std::string"""
        return _digital_swig1.glfsr_source_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(glfsr_source_f_sptr self, std::string name)"""
        return _digital_swig1.glfsr_source_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(glfsr_source_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.glfsr_source_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(glfsr_source_f_sptr self) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(glfsr_source_f_sptr self) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(glfsr_source_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.glfsr_source_f_sptr_message_subscribers(self, which_port)

glfsr_source_f_sptr_swigregister = _digital_swig1.glfsr_source_f_sptr_swigregister
glfsr_source_f_sptr_swigregister(glfsr_source_f_sptr)


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

class hdlc_deframer_bp_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::hdlc_deframer_bp)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::hdlc_deframer_bp)> self) -> hdlc_deframer_bp_sptr
        __init__(boost::shared_ptr<(gr::digital::hdlc_deframer_bp)> self, hdlc_deframer_bp p) -> hdlc_deframer_bp_sptr
        """
        this = _digital_swig1.new_hdlc_deframer_bp_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(hdlc_deframer_bp_sptr self) -> hdlc_deframer_bp"""
        return _digital_swig1.hdlc_deframer_bp_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_hdlc_deframer_bp_sptr
    __del__ = lambda self: None

    def make(self, length_min, length_max):
        """make(hdlc_deframer_bp_sptr self, int length_min, int length_max) -> hdlc_deframer_bp_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_make(self, length_min, length_max)


    def history(self):
        """history(hdlc_deframer_bp_sptr self) -> unsigned int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(hdlc_deframer_bp_sptr self, int which, int delay)
        declare_sample_delay(hdlc_deframer_bp_sptr self, unsigned int delay)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(hdlc_deframer_bp_sptr self, int which) -> unsigned int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(hdlc_deframer_bp_sptr self) -> double"""
        return _digital_swig1.hdlc_deframer_bp_sptr_relative_rate(self)


    def start(self):
        """start(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_start(self)


    def stop(self):
        """stop(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(hdlc_deframer_bp_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(hdlc_deframer_bp_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.hdlc_deframer_bp_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(hdlc_deframer_bp_sptr self, int m)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(hdlc_deframer_bp_sptr self)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(hdlc_deframer_bp_sptr self) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(hdlc_deframer_bp_sptr self, int m)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(hdlc_deframer_bp_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(hdlc_deframer_bp_sptr self, long max_output_buffer)
        set_max_output_buffer(hdlc_deframer_bp_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(hdlc_deframer_bp_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(hdlc_deframer_bp_sptr self, long min_output_buffer)
        set_min_output_buffer(hdlc_deframer_bp_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(hdlc_deframer_bp_sptr self, int which) -> float
        pc_input_buffers_full(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(hdlc_deframer_bp_sptr self, int which) -> float
        pc_input_buffers_full_avg(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(hdlc_deframer_bp_sptr self, int which) -> float
        pc_input_buffers_full_var(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(hdlc_deframer_bp_sptr self, int which) -> float
        pc_output_buffers_full(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(hdlc_deframer_bp_sptr self, int which) -> float
        pc_output_buffers_full_avg(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(hdlc_deframer_bp_sptr self, int which) -> float
        pc_output_buffers_full_var(hdlc_deframer_bp_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(hdlc_deframer_bp_sptr self) -> float"""
        return _digital_swig1.hdlc_deframer_bp_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(hdlc_deframer_bp_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(hdlc_deframer_bp_sptr self)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(hdlc_deframer_bp_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.hdlc_deframer_bp_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(hdlc_deframer_bp_sptr self) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(hdlc_deframer_bp_sptr self, int priority) -> int"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_name(self)


    def symbol_name(self):
        """symbol_name(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(hdlc_deframer_bp_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(hdlc_deframer_bp_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(hdlc_deframer_bp_sptr self) -> long"""
        return _digital_swig1.hdlc_deframer_bp_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(hdlc_deframer_bp_sptr self) -> basic_block_sptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(hdlc_deframer_bp_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.hdlc_deframer_bp_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(hdlc_deframer_bp_sptr self) -> std::string"""
        return _digital_swig1.hdlc_deframer_bp_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(hdlc_deframer_bp_sptr self, std::string name)"""
        return _digital_swig1.hdlc_deframer_bp_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(hdlc_deframer_bp_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.hdlc_deframer_bp_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(hdlc_deframer_bp_sptr self) -> swig_int_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(hdlc_deframer_bp_sptr self) -> swig_int_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(hdlc_deframer_bp_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.hdlc_deframer_bp_sptr_message_subscribers(self, which_port)

hdlc_deframer_bp_sptr_swigregister = _digital_swig1.hdlc_deframer_bp_sptr_swigregister
hdlc_deframer_bp_sptr_swigregister(hdlc_deframer_bp_sptr)


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

class hdlc_framer_pb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::hdlc_framer_pb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::hdlc_framer_pb)> self) -> hdlc_framer_pb_sptr
        __init__(boost::shared_ptr<(gr::digital::hdlc_framer_pb)> self, hdlc_framer_pb p) -> hdlc_framer_pb_sptr
        """
        this = _digital_swig1.new_hdlc_framer_pb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(hdlc_framer_pb_sptr self) -> hdlc_framer_pb"""
        return _digital_swig1.hdlc_framer_pb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_hdlc_framer_pb_sptr
    __del__ = lambda self: None

    def make(self, frame_tag_name):
        """make(hdlc_framer_pb_sptr self, std::string const frame_tag_name) -> hdlc_framer_pb_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_make(self, frame_tag_name)


    def history(self):
        """history(hdlc_framer_pb_sptr self) -> unsigned int"""
        return _digital_swig1.hdlc_framer_pb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(hdlc_framer_pb_sptr self, int which, int delay)
        declare_sample_delay(hdlc_framer_pb_sptr self, unsigned int delay)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(hdlc_framer_pb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.hdlc_framer_pb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(hdlc_framer_pb_sptr self) -> double"""
        return _digital_swig1.hdlc_framer_pb_sptr_relative_rate(self)


    def start(self):
        """start(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_start(self)


    def stop(self):
        """stop(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(hdlc_framer_pb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(hdlc_framer_pb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.hdlc_framer_pb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(hdlc_framer_pb_sptr self, int m)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(hdlc_framer_pb_sptr self)"""
        return _digital_swig1.hdlc_framer_pb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(hdlc_framer_pb_sptr self) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(hdlc_framer_pb_sptr self, int m)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(hdlc_framer_pb_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(hdlc_framer_pb_sptr self, long max_output_buffer)
        set_max_output_buffer(hdlc_framer_pb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(hdlc_framer_pb_sptr self, int i) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(hdlc_framer_pb_sptr self, long min_output_buffer)
        set_min_output_buffer(hdlc_framer_pb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.hdlc_framer_pb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(hdlc_framer_pb_sptr self, int which) -> float
        pc_input_buffers_full(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(hdlc_framer_pb_sptr self, int which) -> float
        pc_input_buffers_full_avg(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(hdlc_framer_pb_sptr self, int which) -> float
        pc_input_buffers_full_var(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(hdlc_framer_pb_sptr self, int which) -> float
        pc_output_buffers_full(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(hdlc_framer_pb_sptr self, int which) -> float
        pc_output_buffers_full_avg(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(hdlc_framer_pb_sptr self, int which) -> float
        pc_output_buffers_full_var(hdlc_framer_pb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.hdlc_framer_pb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(hdlc_framer_pb_sptr self) -> float"""
        return _digital_swig1.hdlc_framer_pb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(hdlc_framer_pb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(hdlc_framer_pb_sptr self)"""
        return _digital_swig1.hdlc_framer_pb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(hdlc_framer_pb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.hdlc_framer_pb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(hdlc_framer_pb_sptr self) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(hdlc_framer_pb_sptr self, int priority) -> int"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(hdlc_framer_pb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(hdlc_framer_pb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(hdlc_framer_pb_sptr self) -> long"""
        return _digital_swig1.hdlc_framer_pb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(hdlc_framer_pb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(hdlc_framer_pb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.hdlc_framer_pb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(hdlc_framer_pb_sptr self) -> std::string"""
        return _digital_swig1.hdlc_framer_pb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(hdlc_framer_pb_sptr self, std::string name)"""
        return _digital_swig1.hdlc_framer_pb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(hdlc_framer_pb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.hdlc_framer_pb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(hdlc_framer_pb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(hdlc_framer_pb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(hdlc_framer_pb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.hdlc_framer_pb_sptr_message_subscribers(self, which_port)

hdlc_framer_pb_sptr_swigregister = _digital_swig1.hdlc_framer_pb_sptr_swigregister
hdlc_framer_pb_sptr_swigregister(hdlc_framer_pb_sptr)


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

class header_payload_demux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_payload_demux)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_payload_demux)> self) -> header_payload_demux_sptr
        __init__(boost::shared_ptr<(gr::digital::header_payload_demux)> self, header_payload_demux p) -> header_payload_demux_sptr
        """
        this = _digital_swig1.new_header_payload_demux_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(header_payload_demux_sptr self) -> header_payload_demux"""
        return _digital_swig1.header_payload_demux_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_header_payload_demux_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(header_payload_demux_sptr self, int const header_len, int const items_per_symbol=1, int const guard_interval=0, std::string const & length_tag_key, std::string const & trigger_tag_key, bool const output_symbols=False, size_t const itemsize, std::string const & timing_tag_key, double const samp_rate=1.0, std::vector< std::string,std::allocator< std::string > > const & special_tags, size_t const header_padding=0) -> header_payload_demux_sptr"""
        return _digital_swig1.header_payload_demux_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(header_payload_demux_sptr self) -> unsigned int"""
        return _digital_swig1.header_payload_demux_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(header_payload_demux_sptr self, int which, int delay)
        declare_sample_delay(header_payload_demux_sptr self, unsigned int delay)
        """
        return _digital_swig1.header_payload_demux_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(header_payload_demux_sptr self, int which) -> unsigned int"""
        return _digital_swig1.header_payload_demux_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(header_payload_demux_sptr self) -> double"""
        return _digital_swig1.header_payload_demux_sptr_relative_rate(self)


    def start(self):
        """start(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_start(self)


    def stop(self):
        """stop(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(header_payload_demux_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(header_payload_demux_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.header_payload_demux_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(header_payload_demux_sptr self, int m)"""
        return _digital_swig1.header_payload_demux_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(header_payload_demux_sptr self)"""
        return _digital_swig1.header_payload_demux_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(header_payload_demux_sptr self) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(header_payload_demux_sptr self, int m)"""
        return _digital_swig1.header_payload_demux_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(header_payload_demux_sptr self, int i) -> long"""
        return _digital_swig1.header_payload_demux_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(header_payload_demux_sptr self, long max_output_buffer)
        set_max_output_buffer(header_payload_demux_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.header_payload_demux_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(header_payload_demux_sptr self, int i) -> long"""
        return _digital_swig1.header_payload_demux_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(header_payload_demux_sptr self, long min_output_buffer)
        set_min_output_buffer(header_payload_demux_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.header_payload_demux_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(header_payload_demux_sptr self, int which) -> float
        pc_input_buffers_full(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(header_payload_demux_sptr self, int which) -> float
        pc_input_buffers_full_avg(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(header_payload_demux_sptr self, int which) -> float
        pc_input_buffers_full_var(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(header_payload_demux_sptr self, int which) -> float
        pc_output_buffers_full(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(header_payload_demux_sptr self, int which) -> float
        pc_output_buffers_full_avg(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(header_payload_demux_sptr self, int which) -> float
        pc_output_buffers_full_var(header_payload_demux_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.header_payload_demux_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(header_payload_demux_sptr self) -> float"""
        return _digital_swig1.header_payload_demux_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(header_payload_demux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.header_payload_demux_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(header_payload_demux_sptr self)"""
        return _digital_swig1.header_payload_demux_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(header_payload_demux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.header_payload_demux_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(header_payload_demux_sptr self) -> int"""
        return _digital_swig1.header_payload_demux_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(header_payload_demux_sptr self, int priority) -> int"""
        return _digital_swig1.header_payload_demux_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_name(self)


    def symbol_name(self):
        """symbol_name(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(header_payload_demux_sptr self) -> io_signature_sptr"""
        return _digital_swig1.header_payload_demux_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(header_payload_demux_sptr self) -> io_signature_sptr"""
        return _digital_swig1.header_payload_demux_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(header_payload_demux_sptr self) -> long"""
        return _digital_swig1.header_payload_demux_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(header_payload_demux_sptr self) -> basic_block_sptr"""
        return _digital_swig1.header_payload_demux_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(header_payload_demux_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.header_payload_demux_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(header_payload_demux_sptr self) -> std::string"""
        return _digital_swig1.header_payload_demux_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(header_payload_demux_sptr self, std::string name)"""
        return _digital_swig1.header_payload_demux_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(header_payload_demux_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.header_payload_demux_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(header_payload_demux_sptr self) -> swig_int_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(header_payload_demux_sptr self) -> swig_int_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(header_payload_demux_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.header_payload_demux_sptr_message_subscribers(self, which_port)

header_payload_demux_sptr_swigregister = _digital_swig1.header_payload_demux_sptr_swigregister
header_payload_demux_sptr_swigregister(header_payload_demux_sptr)


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

class kurtotic_equalizer_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::kurtotic_equalizer_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::kurtotic_equalizer_cc)> self) -> kurtotic_equalizer_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::kurtotic_equalizer_cc)> self, kurtotic_equalizer_cc p) -> kurtotic_equalizer_cc_sptr
        """
        this = _digital_swig1.new_kurtotic_equalizer_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(kurtotic_equalizer_cc_sptr self) -> kurtotic_equalizer_cc"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_kurtotic_equalizer_cc_sptr
    __del__ = lambda self: None

    def make(self, num_taps, mu):
        """make(kurtotic_equalizer_cc_sptr self, int num_taps, float mu) -> kurtotic_equalizer_cc_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_make(self, num_taps, mu)


    def gain(self):
        """gain(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_gain(self)


    def set_gain(self, mu):
        """set_gain(kurtotic_equalizer_cc_sptr self, float mu)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_gain(self, mu)


    def history(self):
        """history(kurtotic_equalizer_cc_sptr self) -> unsigned int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(kurtotic_equalizer_cc_sptr self, int which, int delay)
        declare_sample_delay(kurtotic_equalizer_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(kurtotic_equalizer_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(kurtotic_equalizer_cc_sptr self) -> double"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_relative_rate(self)


    def start(self):
        """start(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_start(self)


    def stop(self):
        """stop(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(kurtotic_equalizer_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(kurtotic_equalizer_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(kurtotic_equalizer_cc_sptr self, int m)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(kurtotic_equalizer_cc_sptr self)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(kurtotic_equalizer_cc_sptr self) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(kurtotic_equalizer_cc_sptr self, int m)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(kurtotic_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(kurtotic_equalizer_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(kurtotic_equalizer_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(kurtotic_equalizer_cc_sptr self, int i) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(kurtotic_equalizer_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(kurtotic_equalizer_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(kurtotic_equalizer_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(kurtotic_equalizer_cc_sptr self) -> float"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(kurtotic_equalizer_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(kurtotic_equalizer_cc_sptr self)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(kurtotic_equalizer_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(kurtotic_equalizer_cc_sptr self) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(kurtotic_equalizer_cc_sptr self, int priority) -> int"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(kurtotic_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(kurtotic_equalizer_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(kurtotic_equalizer_cc_sptr self) -> long"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(kurtotic_equalizer_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(kurtotic_equalizer_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(kurtotic_equalizer_cc_sptr self) -> std::string"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(kurtotic_equalizer_cc_sptr self, std::string name)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(kurtotic_equalizer_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(kurtotic_equalizer_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(kurtotic_equalizer_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(kurtotic_equalizer_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.kurtotic_equalizer_cc_sptr_message_subscribers(self, which_port)

kurtotic_equalizer_cc_sptr_swigregister = _digital_swig1.kurtotic_equalizer_cc_sptr_swigregister
kurtotic_equalizer_cc_sptr_swigregister(kurtotic_equalizer_cc_sptr)


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

class map_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::map_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::map_bb)> self) -> map_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::map_bb)> self, map_bb p) -> map_bb_sptr
        """
        this = _digital_swig1.new_map_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(map_bb_sptr self) -> map_bb"""
        return _digital_swig1.map_bb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_map_bb_sptr
    __del__ = lambda self: None

    def make(self, map):
        """make(map_bb_sptr self, std::vector< int,std::allocator< int > > const & map) -> map_bb_sptr"""
        return _digital_swig1.map_bb_sptr_make(self, map)


    def set_map(self, map):
        """set_map(map_bb_sptr self, std::vector< int,std::allocator< int > > const & map)"""
        return _digital_swig1.map_bb_sptr_set_map(self, map)


    def map(self):
        """map(map_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.map_bb_sptr_map(self)


    def history(self):
        """history(map_bb_sptr self) -> unsigned int"""
        return _digital_swig1.map_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(map_bb_sptr self, int which, int delay)
        declare_sample_delay(map_bb_sptr self, unsigned int delay)
        """
        return _digital_swig1.map_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(map_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig1.map_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(map_bb_sptr self) -> double"""
        return _digital_swig1.map_bb_sptr_relative_rate(self)


    def start(self):
        """start(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_start(self)


    def stop(self):
        """stop(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(map_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(map_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.map_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(map_bb_sptr self, int m)"""
        return _digital_swig1.map_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(map_bb_sptr self)"""
        return _digital_swig1.map_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(map_bb_sptr self) -> bool"""
        return _digital_swig1.map_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(map_bb_sptr self, int m)"""
        return _digital_swig1.map_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(map_bb_sptr self, int i) -> long"""
        return _digital_swig1.map_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(map_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(map_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.map_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(map_bb_sptr self, int i) -> long"""
        return _digital_swig1.map_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(map_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(map_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.map_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(map_bb_sptr self, int which) -> float
        pc_input_buffers_full(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(map_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(map_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(map_bb_sptr self, int which) -> float
        pc_output_buffers_full(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(map_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(map_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(map_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.map_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(map_bb_sptr self) -> float"""
        return _digital_swig1.map_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(map_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.map_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(map_bb_sptr self)"""
        return _digital_swig1.map_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(map_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.map_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(map_bb_sptr self) -> int"""
        return _digital_swig1.map_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(map_bb_sptr self, int priority) -> int"""
        return _digital_swig1.map_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(map_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.map_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(map_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig1.map_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(map_bb_sptr self) -> long"""
        return _digital_swig1.map_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(map_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig1.map_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(map_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.map_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(map_bb_sptr self) -> std::string"""
        return _digital_swig1.map_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(map_bb_sptr self, std::string name)"""
        return _digital_swig1.map_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(map_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.map_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(map_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.map_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(map_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig1.map_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(map_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.map_bb_sptr_message_subscribers(self, which_port)

map_bb_sptr_swigregister = _digital_swig1.map_bb_sptr_swigregister
map_bb_sptr_swigregister(map_bb_sptr)


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

class msk_timing_recovery_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::msk_timing_recovery_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::msk_timing_recovery_cc)> self) -> msk_timing_recovery_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::msk_timing_recovery_cc)> self, msk_timing_recovery_cc p) -> msk_timing_recovery_cc_sptr
        """
        this = _digital_swig1.new_msk_timing_recovery_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(msk_timing_recovery_cc_sptr self) -> msk_timing_recovery_cc"""
        return _digital_swig1.msk_timing_recovery_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig1.delete_msk_timing_recovery_cc_sptr
    __del__ = lambda self: None

    def make(self, sps, gain, limit, osps):
        """make(msk_timing_recovery_cc_sptr self, float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_make(self, sps, gain, limit, osps)


    def set_gain(self, gain):
        """set_gain(msk_timing_recovery_cc_sptr self, float gain)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_gain(self, gain)


    def get_gain(self):
        """get_gain(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_gain(self)


    def set_limit(self, limit):
        """set_limit(msk_timing_recovery_cc_sptr self, float limit)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_limit(self, limit)


    def get_limit(self):
        """get_limit(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_limit(self)


    def set_sps(self, sps):
        """set_sps(msk_timing_recovery_cc_sptr self, float sps)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_sps(self, sps)


    def get_sps(self):
        """get_sps(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_get_sps(self)


    def history(self):
        """history(msk_timing_recovery_cc_sptr self) -> unsigned int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(msk_timing_recovery_cc_sptr self, int which, int delay)
        declare_sample_delay(msk_timing_recovery_cc_sptr self, unsigned int delay)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(msk_timing_recovery_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(msk_timing_recovery_cc_sptr self) -> double"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_relative_rate(self)


    def start(self):
        """start(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_start(self)


    def stop(self):
        """stop(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(msk_timing_recovery_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(msk_timing_recovery_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(msk_timing_recovery_cc_sptr self)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(msk_timing_recovery_cc_sptr self) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(msk_timing_recovery_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(msk_timing_recovery_cc_sptr self)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(msk_timing_recovery_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(msk_timing_recovery_cc_sptr self, int priority) -> int"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(msk_timing_recovery_cc_sptr self) -> long"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(msk_timing_recovery_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(msk_timing_recovery_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(msk_timing_recovery_cc_sptr self, std::string name)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(msk_timing_recovery_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig1.msk_timing_recovery_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(msk_timing_recovery_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(msk_timing_recovery_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(msk_timing_recovery_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig1.msk_timing_recovery_cc_sptr_message_subscribers(self, which_port)

msk_timing_recovery_cc_sptr_swigregister = _digital_swig1.msk_timing_recovery_cc_sptr_swigregister
msk_timing_recovery_cc_sptr_swigregister(msk_timing_recovery_cc_sptr)


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



